CryptoPatrick

About Me

Tue, 13 Jan 2026 00:00:00 +0000

Who am I?: Hi! My name is Patrick. I was born and raised in Gothenburg, on the Swedish West Coast. I’m a trained Computational Linguist, specializing in Large Language Models (LLM) and Agentic Artificial Intelligence. I’m passionate about building systems that are simple, have few parts, are easy to maintain, and very fast. I’m looking for my first professional developer role. I have several years of experience in developing Open Source Software.

jax-rs

Sun, 28 Dec 2025 00:00:00 +0000

What it is

JAX is Google’s library for numerical computing: NumPy-style arrays plus transformations like grad that compute derivatives automatically. jax-rs brings that model to Rust. It has an Array type with broadcasting and NumPy-like operations, reverse-mode automatic differentiation by tracing computations into a graph, kernel fusion, and a WebGPU backend for running on the GPU, including in the browser.

Using it

use jax_rs::{Array, Shape};

let x = Array::from_vec(vec![1.0, 2.0, 3.0, 4.0], Shape::new(vec![2, 2]));
let y = Array::from_vec(vec![5.0, 6.0, 7.0, 8.0], Shape::new(vec![2, 2]));

let sum = x.add(&y);          // element-wise
let prod = x.matmul(&y);      // matrix product
let mean = x.mean_all();      // 2.5

Derivatives:

Ripley

Tue, 16 Dec 2025 00:00:00 +0000

What it is

Model quality can change from one week to the next without notice. Ripley is a small daemon that runs simple, deterministic test tasks against the Claude Code CLI on a schedule, scores each run on correctness, token use and duration, and stores the results in SQLite. Rolling statistics flag when the pass rate drops. It is named after Ellen Ripley, who follows procedure and notices when systems that claim to be fine aren’t.

cargo-x402

Thu, 27 Nov 2025 00:00:00 +0000

What it is

x402 revives HTTP status code 402 Payment Required: a server can ask for a small payment before serving a request, and a client (or an AI agent) can pay and retry automatically. It makes pay-per-request APIs possible without accounts or subscriptions.

cargo-x402 is a cargo subcommand that starts a new x402 project from a template. It finds templates in GitHub repositories tagged x402-template, lets you pick one interactively, and fills in the project name and options. I wrote five templates for it: a basic API, a CLI, a full-stack app, an observability setup and a starter kit.

AgentFS

Tue, 25 Nov 2025 00:00:00 +0000

What it is

Agents need somewhere to put things: files they produce, settings they keep, and a record of the tools they called. AgentFS gives an agent a POSIX-like workspace with three parts:

fs: files and directories (mkdir, write_file, read_file, readdir, …),
kv: a key-value store for state and configuration,
tools: an audit log of tool calls with their inputs, outputs, outcome and statistics.

Everything is stored in a database. AgentFS is built on agentdb, a database-independent interface, and agentsql, which implements it for SQLite, PostgreSQL and MySQL.

AgentSmith

Sun, 16 Nov 2025 00:00:00 +0000

What it is

Most agents forget everything when the process stops. AgentSmith wraps an agent built with the Rust Rig framework and records every turn in a SQLite database with full-text search, the way Atuin does for shell history. Before each reply, it searches past conversations for relevant turns and adds them to the prompt.

Using it

use agentsmith::{AgentHistory, SmartAgent};
use rig::providers::openai;

let history = AgentHistory::new("my_agent.db", Some("session-123")).await?;

let client = openai::Client::new(&std::env::var("OPENAI_API_KEY")?);
let agent = client.agent("gpt-4").preamble("You are a helpful assistant.").build();

let mut smart = SmartAgent::new(agent, history);
let reply = smart.chat("How did we fix the JSON parsing bug?").await?;

AgentHistory can also be used directly: log_turn records a message with metadata (duration, success, tokens), search and recent retrieve turns, summarize_session writes a summary, and import_jsonl loads an existing log.

Foras

Thu, 09 Oct 2025 00:00:00 +0000

What it is

Foras (First-Order ReASoner) is an automated theorem prover for first-order logic with equality. You give it axioms and the negation of a goal; it searches for a contradiction using resolution and paramodulation, and either prints a proof or reports that the search saturated without finding one.

It started as a small reasoner and became a faithful port of Otter 3.3, William McCune’s classic prover from Argonne National Laboratory. “Faithful” is measured, not claimed: a tool compares Foras’s search with C Otter’s clause by clause. On Otter’s 81 reference examples, 70 produce identical searches and the other 11 match up to the point where Otter’s memory accounting takes over.

miniFIX Tutorial | Part 08

Mon, 22 Sep 2025 00:00:00 +0000

In production financial systems, security is paramount. FIX messages often contain sensitive trading information that must be protected during transmission. TLS (Transport Layer Security) provides the cryptographic foundation for secure FIX communication. This post explores building a TLS-enabled FIX acceptor using miniFIX, focusing on security best practices for financial applications.

miniFIX Tutorial | Part 07

Sun, 21 Sep 2025 00:00:00 +0000

Simple Open Framing Header (SOFH) is a lightweight framing protocol often used to wrap FIX messages for reliable transport over TCP connections. When building high-throughput financial systems, combining SOFH framing with async Rust provides excellent performance characteristics. This post demonstrates how to build a SOFH-enabled TCP server using miniFIX and Tokio.

miniFIX Tutorial | Part 06

Sat, 20 Sep 2025 00:00:00 +0000

Modern trading systems require interactive, user-friendly interfaces that can handle real-time market data and order management. This post explores building an interactive trading client using miniFIX with Tokio for async operations, combined with a command-line interface for trader interaction.

miniFIX Tutorial | Part 05

Fri, 19 Sep 2025 00:00:00 +0000

Modern financial systems often need to work with multiple message formats. While FIX is the standard for electronic trading, many systems also use JSON for APIs, configuration, testing, and integration with web-based interfaces. miniFIX provides seamless conversion between JSON and FIX tag=value formats, enabling flexible system architectures.

miniFIX Tutorial | Part 04

Thu, 18 Sep 2025 00:00:00 +0000

While standard FIX specifications (4.0, 4.1, 4.2, 4.4, etc.) cover most trading scenarios, many organizations need custom fields and message types. Exchanges like Coinbase often extend FIX with proprietary fields for their specific business needs. miniFIX supports custom specifications through QuickFIX XML format and provides code generation capabilities to create type-safe Rust definitions.

miniFIX Tutorial | Part 03

Wed, 17 Sep 2025 00:00:00 +0000

While decoding FIX messages is essential for processing incoming data, encoding messages is equally important for sending orders, confirmations, and other trading instructions. miniFIX provides a powerful, type-safe encoder that makes creating FIX messages straightforward while maintaining the performance and reliability needed for financial applications.

miniFIX Tutorial | Part 02

Tue, 16 Sep 2025 00:00:00 +0000

In real-world trading applications, FIX messages often arrive as continuous streams over network connections. Unlike processing individual complete messages, streaming scenarios require handling partial messages, buffering incomplete data, and parsing messages as they arrive. miniFIX provides excellent support for streaming FIX message decoding.

harel

Mon, 15 Sep 2025 00:00:00 +0000

What it is

David Harel’s statecharts extend finite state machines with nested states, parallel regions and history, which makes complex behaviour (a microwave, a traffic light, a voice dialogue) much easier to describe. SCXML is the W3C standard for writing statecharts as XML.

harel parses SCXML documents into typed Rust structures (<state>, <parallel>, <final>, transitions, data model, <invoke>), checks that they are well formed, and writes them back out as XML.

isu

Mon, 15 Sep 2025 00:00:00 +0000

What it is

Information State Update (ISU) is a theory of dialogue from computational linguistics: a conversation is a shared information state (what has been said, what is agreed, which questions are open), and every utterance is a dialogue move that updates it according to rules. The IBIS model organises the state around the questions under discussion.

isu is a Rust implementation of an IBIS-style dialogue manager: domain knowledge (predicates, sorts, individuals), a database interface, plans that say what to find out, and a grammar that maps between text and dialogue moves. It ships with a complete travel-booking example.

miniFIX Tutorial | Part 01

Mon, 15 Sep 2025 00:00:00 +0000

The Financial Information eXchange (FIX) protocol is the backbone of electronic trading in financial markets. If you’re building trading systems in Rust, miniFIX provides a modern, type-safe way to work with FIX messages. In this post, we’ll explore how to decode FIX messages using miniFIX’s powerful decoding capabilities.

miniFIX Tutorial Series

Sun, 14 Sep 2025 00:00:00 +0000

Intro to a comprehensive blog post tutorial series covering all aspects of the miniFIX Rust crate, from basic usage to advanced production scenarios.

PGF Specification 1.0

Fri, 05 Sep 2025 00:00:00 +0000

Just something I read and found interesting.

pgf2json

Wed, 03 Sep 2025 00:00:00 +0000

What it is

When the Grammatical Framework compiler builds a grammar, it writes a binary Portable Grammar Format (PGF) file. pgf2json reads that binary format into Rust data structures and converts it into structured JSON: functions, categories and each language’s concrete syntax. It can also parse a sentence with the loaded grammar. It is the loading layer underneath gf-core.

Using it

use pgf2json::{read_pgf, pgf_to_json, parse, language, types};

// Load a compiled grammar
let pgf = read_pgf("./grammars/Food.pgf")?;

// The whole grammar as JSON
let json = pgf_to_json(&pgf)?;

// Parse a sentence with the English concrete syntax
let lang = language::read_language("FoodEng").unwrap();
let typ = types::start_cat(&pgf);
let trees = parse(&pgf, &lang, &typ, "this pizza is delicious")?;

Ideas for using it

Inspect a grammar. Dump a PGF to JSON to see what a grammar actually contains, which is handy when debugging a grammar written by someone else.
Grammars in the browser. Ship the JSON to a web front end and run parsing or generation in JavaScript.
Diff grammar versions. JSON makes it easy to compare two compiled versions of a grammar.

Status

Stable for PGF 1.0. Support for PGF 2.1 is experimental: there is a known format difference still to handle.

Agentic Micro Economy

Wed, 20 Aug 2025 00:00:00 +0000

Just something I read and found interesting.

The Time Lock

Mon, 13 Jan 2025 00:00:00 +0000

Version: 0.5.0 Unreleased Draft

The Rebel Commander never expected the mission to be a walk in the Simulation Park, but the current situation was best described as a tactical nightmare
⠀⠀⠀⠀⠀ - and time…was running out.
⠀⠀⠀⠀⠀ “Our medical team sure know their shit,” the female Sargent accross the planning table broke the silence , an attempt to thableacche boasted without looking up from the print image. ⠀⠀⠀⠀⠀ On the table in front of him was a grainy image printout, of a number. During the last four hours, the medical team had managed to salvage and extract fragments of a few visual memories from the female Federalist’s damaged brain. Most memories were stored in old neuron clusters, encoding what the team interpreted to be childhood memories; learning to ride a jetbike, some kind of 1st-in-class trophy, acceptance to the Federation Juvenile Military Academy, and so forth.
⠀⠀⠀⠀⠀ On the verge of giving up, the Rebel medical team then stumbled on a tiny neuro-cluster, bordering a massive volume of dead neurons. Similar to the “childhood memory” cluster, this tiny cluster of neurons appeared to encode the aggregate feeling of “pride and accomplishment”. However, in contrast, these neurons had recently been stimulated!, not by the medical team’s nano robots, but by a surge of pure old-fashioned neurotransmitters, presumably to encode a recent and strong sense of accomplishment by the host.
⠀⠀⠀⠀⠀ The medical team then decided to try a new, but highly controversial, Interogation NeurOp Procedure. They tortured Angela’s long-time colleague, Yuhey, and fed the recorded sound of his primal screams straight into her still functional hearing receptors. As expected, these horrific signals triggered a deeply traumatic experience in Angela’s half-dead brain. Her brainstem responded by releasing a massive burst of excitatory neurotransmitters. This in turn gave rise to neural activity in the form of new neural pathways being created in almost every area of her brain which still contained living neurons, to encode potentially life-saving information. With this “trap” in place, the nano robots managed to entice individual neurons in the tiny cluster to connect, and once chemically consolidated, an “interface” into the high-value target memories was complete. The NeurOp had succeeded.
⠀⠀⠀⠀⠀ Building on top of that breakthrough, the team then relied on 31st century standard medical procedures for patients with traumatic brain injury - to map, copy, and virtualize the structure, density, and impedance of the cluster. Basically creating a biosynthetic 1:1 copy of the memory cluster, which could then be rendered back into the format that triggered the memory encoding in the first place. The final result of the entire operation now lay in front of the Rebel commander, in the form of a printed image, depicting a number:
$$\mathsf{691200}$$

Squarings Modulo N per Second

Thu, 19 Dec 2024 00:00:00 +0000

A quick, non-scientific, look at how we might estimate the number of squarings modulo n that a computer can perform per second.

Block Time-Lock Messages

Thu, 12 Dec 2024 00:00:00 +0000

Exploring how to use Bitcoin block hashes as time-dependent keys for encrypting messages that can only be decrypted after a specific block is mined.

Const Generics

Fri, 06 Dec 2024 00:00:00 +0000

A look at const generics in Rust, explained through a Dungeons & Dragons magic system analogy.

Avalonia UI on MacOS

Thu, 17 Oct 2024 00:00:00 +0000

Description: How to get Avalonia setup on MacOS (Big Sur).

For VS Code users there’s an extension that can help speed up development process. You can find it on the VS Code Extension marketplace

Step: Install .NET

$ dotnet new install Avalonia.Templates
# Check installation:
$ dotnet --version

Step: Install Avalonia

Using the .NET CLI we install the Avalonia UI templates. We can install Avalonia project templates with the following command:

Cargo Deploy

Wed, 25 Sep 2024 00:00:00 +0000

In this post we’ll create our own third-party cargo subcommand, cargo deploy. When we call our command in a Rust project, the command will send a binary to our server at Netlify, and print out the URL in the command line. Let’s get started.

Naming

The binary of our command needs to be named cargo-${command}. In our case we’ll name it cargo-deploy.

Placement

The binary of our command needs to be stored in ~/.cargo/bin. There’s an easy way to do this: we simply create the binary (named cargo-deploy) and then publish it to crates.io. Then, cargo install cargo-deploy will download and place the binary in ~/.cargo/bin.

Logging

Wed, 25 Sep 2024 00:00:00 +0000

A quick post looking at two ways to do logging in a Rust code-base.

Fixed Point Theory

Mon, 10 Jun 2024 00:00:00 +0000

We start from scratch and try to build our understanding of the most fundamental idea of Fixed Point Theory- the Banach Contraction Principle.

gf-core

Sat, 01 Jun 2024 00:00:00 +0000

What it is

Grammatical Framework (GF) is a programming language for grammars. You write one abstract syntax (what can be said) and one concrete syntax per language (how it’s said). The GF compiler turns them into a PGF file, and a runtime uses that file to parse text into trees and linearise trees back into text, in any of the languages.

gf-core is a runtime for those compiled grammars, written in Rust, so GF can be embedded in Rust programs without the Haskell toolchain at run time. It is a runtime only: grammars are still compiled with the official GF compiler.

Solana 101

Fri, 12 Apr 2024 00:00:00 +0000

I start by reading the Solana documentation and will see how far I get in building something with Solana.

graph_mvcc

Wed, 30 Aug 2023 00:00:00 +0000

What it is

Databases let many transactions run at once without reading each other’s half-finished changes. Multiversion concurrency control (MVCC) does this by keeping several versions of each record: every transaction sees a consistent snapshot from the moment it started, and writes become visible only on commit.

graph_mvcc applies that idea to a graph. Nodes and edges are created inside transactions, edges carry a type, and a transaction either commits all its changes or rolls them all back. I wrote about the design in MVCC 101.

MVCC 101

Sun, 20 Aug 2023 00:00:00 +0000

MVCC stands for MultiVersion Concurrency Control. It’s a way to implement transactional isolation in any application that needs to manage the state of data items.

The traditional mechanism for state management in a database is concurrent control using read-write locks. However, this solution is based on blocking and can create contention. MVCC is not blocking. This means that multiple clients can read and write simultaneously - reads do not block other reads and writes do not block other writes or reads.

Graph Database

Sat, 29 Jul 2023 00:00:00 +0000

A beginner-oriented post containing a few fundamental concepts, and usually a step-by-step rudimentary example. I’m hoping this post will serve as a quick refresher on the covered subject. The content of the post is usually heavily inspired by books and Wiki - my aim is to have a post close at hand if I need to refresh my memory. For proper tutorials and primers - please see other sources on the Internet.

REST API

Mon, 04 Apr 2022 00:00:00 +0000

I recently started using Axum, a web framework for Rust, and I’m a fan of it so far. I’m writing this post to document my learning process and cover how to build a REST API using Axum as a web framework and SQLx for SQL queries. Let’s go!