zigforge

import os
import json
import subprocess
from anthropic import Anthropic

# Tool definitions
TOOLS = [
    {
        "name": "list_files",
        "description": "List files and directories at a given path",

zigforge

interface QueueItem<T, R> {
  task: T;
  resolve: (result: R) => void;
  reject: (error: Error) => void;
}

type Worker<T, R> = (task: T) => Promise<R>;

export class WorkerQueue<T, R> {
  queue: QueueItem<T, R>[];

zigforge

import { Client } from "@upstash/qstash"
import { NextRequest } from "next/server"

const baseUrl = process.env.NEXT_PUBLIC_VERCEL_PROJECT_PRODUCTION_URL
  ? `https://${process.env.NEXT_PUBLIC_VERCEL_PROJECT_PRODUCTION_URL}`
  : "http://localhost:3000"

interface Step<I> {
  create: <O>(action: (prevResult: Awaited<I>) => O) => Step<O>
  finally: (action: (prevResult: Awaited<I>) => any) => any

zigforge

This article show you the ultimate way to set up a transparent proxy on Linux using clash and iptables to bypass the GFW in China.

We use:

• clash as the proxy software
• online subconverter and crontab to periodically update config file.
• ACL4SSR to provide GFW rules.

You can go to github gist to download all files mentioned in this article.

zigforge

#!/bin/bash

# Function to display usage information
usage() {
    echo "Usage: $0 /path/to/input.mp4 [ /path/to/output_directory ]"
    exit 1
}

# Check if at least one argument (input file) is provided
if [ $# -lt 1 ]; then

zigforge

Install FreeBSD 14.1 on Hetzner server

Hetzner no longer offers direct install of FreeBSD, but we can do it ourselves. Here is how :)

Boot the server into rescue mode

Boot the Hetzner server in Hetzner Debian based rescue mode. ssh into it.

The Hetzner rescue image will tell you hardware details about the server in the login banner. For example, with one of my servers I see:

zigforge

import os
import base64
import streamlit as st
from mistralai import Mistral
from PIL import Image
import io
from dotenv import load_dotenv

# 加载 .env 文件
load_dotenv()

zigforge

# Zero-downtime deployment script for a Django project with multiple websites (each as a separate app) 
#hosted on an Ubuntu server, passing through GitHub Actions and using MySQL on a separate database server, 
#follow these steps. This process ensures that updates are deployed without downtime.

#!/bin/bash

# Set the directory path
directory="/Users/homesachin/Desktop/zoneone/practice"

zigforge

Install and configure BIND9 as caching DNS nameserver [Debian/Ubuntu]

This tutorial shows how to set-up and configure BIND9 as domain name server (DNS) in caching mode on Debian/Ubuntu based Linux system.

Instalation

sudo apt-get install bind9

BIND configuration

zigforge

Accelerating Discrete Program Search

I am investigating how to use Bend (a parallel language) to accelerate Symbolic AI; in special, Discrete Program Search. Basically, think of it as an alternative to LLMs, GPTs, NNs, that is also capable of generating code, but by entirely different means. This kind of approach was never scaled with mass compute before - it wasn't possible! - but Bend changes this. So, my idea was to do it, and see where it goes.

Now, while I was implementing some candidate algorithms on Bend, I realized that, rather than mass parallelism, I could use an entirely different mechanism to speed things up: SUP Nodes. Basically, it is a feature that Bend inherited from its underlying model ("Interaction Combinators") that, in simple terms, allows us to combine multiple functions into a single superposed one, and apply them all to an argument "at the same time". In short, it allows us to call N functions at a fraction of the expected cost. Or, in simple terms: why parallelize when we can sha