Most coding agents generate suggestions.

Viceroy generates directly applicable edits.

It gives agents a deterministic editing interface for producing whole-file replacements or exact verbatim swaps—never vague instructions such as “insert this somewhere nearby and hope the indentation spirits are cooperative.”

Edits can be:

• applied automatically
• verified locally
• benchmarked objectively
• reproduced without an LLM judge
• checked for unintended collateral changes

Viceroy is built for coding agents that need to modify real repositories reliably, not merely describe what a competent engineer might do.

Project: github.com/andrewrgarcia/viceroy

Chat history is not the same thing as memory.

FUR provides structured conversation control for long-running AI workflows.

It helps manage:

• active context
• interaction history
• message traceability
• branching conversational state
• retrieval from earlier exchanges
• persistent records outside a model's context window

Instead of treating every conversation as an increasingly swollen string, FUR treats interaction history as structured information.

Because eventually every AI chat becomes an attic, and somebody has to label the boxes.

Project: crates.io/crates/fur-cli

Repositories grow larger than context windows.

Yggdrasil turns a codebase into a single structured Markdown artifact for AI workflows.

It collects project structure and source content into an injectable representation that language models can inspect without manually opening files one at a time.

That makes it useful for:

• repository-wide reasoning
• coding-agent context
• audits and reviews
• architectural analysis
• long-context prompting
• reproducible project snapshots

Think of it as compiling software into knowledge an AI can carry around.

Project: crates.io/crates/yggdrasil-cli

Moxi is a programming language for designing 3D worlds in syntax close to natural language.

A Moxi program is an ordinary Markdown file describing atoms, materials, entities, geometry, and relationships.

That makes Moxi readable by humans, straightforward to version with Git, and predictable enough for language models to generate.

# Birthday Cake
> A layered cake with frosting and three candles.

atom CAKE   { color = "#FFC0CB" }
atom CREAM  { color = purple }
atom WAX    { color = white }
atom FLAME  { color = orange }

material Cake   { voxel_atom = CAKE }
material Cream  { voxel_atom = CREAM }
material Wax    { voxel_atom = WAX }
material Flame  { voxel_atom = FLAME }

entity BirthdayCake {
    part Base         { shape = cylinder(height=4, radius=8), material = Cake }
    part Frosting     { shape = cylinder(height=1, radius=8), material = Cream }
    part TopLayer     { shape = cylinder(height=3, radius=6), material = Cake }
    part TopFrosting  { shape = cylinder(height=1, radius=6), material = Cream }

    part LeftCandle   { shape = cylinder(height=5, radius=0.5), material = Wax }
    part CenterCandle { shape = cylinder(height=5, radius=0.5), material = Wax }
    part RightCandle  { shape = cylinder(height=5, radius=0.5), material = Wax }

    part LeftFlame    { shape = sphere(radius=0.8), material = Flame }
    part CenterFlame  { shape = sphere(radius=0.8), material = Flame }
    part RightFlame   { shape = sphere(radius=0.8), material = Flame }

    relation {
        Frosting     above Base
        TopLayer     above Frosting
        TopFrosting  above TopLayer

        CenterCandle above TopFrosting
        LeftCandle   left_of CenterCandle
        RightCandle  right_of CenterCandle

        LeftFlame    above LeftCandle
        CenterFlame  above CenterCandle
        RightFlame   above RightCandle
    }

    resolve voxel_size = 1.0
}

print BirthdayCake detail=low

The Rust-based Moxi compiler transforms source programs into voxel scenes, meshes, and exportable 3D assets.

The browser-based Moxi Sandbox provides:

• source editing
• local compilation
• live 3D rendering
• multiple rendering modes
• image sharing
• GLB export
• immediate compiler feedback

Instead of asking an AI to emit thousands of vertices, you ask it to write a world.

The compiler builds the rest.

Sandbox: moxi-next.vercel.app

Slide editors are useful until a presentation needs version control, automation, reusable structure, or large-scale revision.

Deckmaster treats presentations as programmable documents.

Slides become source rather than opaque editor state, making room for:

• reproducible builds
• reusable components
• automated generation
• version-controlled changes
• structured technical content
• AI-assisted authoring
• consistent visual systems

The goal is not merely to generate slides.

It is to make presentations behave more like software.

Editor: deckmaster-editor.vercel.app

Good software survives contact with reality.

That means building systems that are:

• deterministic instead of magical
• observable instead of mysterious
• reproducible instead of anecdotal
• composable instead of monolithic
• maintainable after the original excitement wears off
• useful after the demonstration ends

I prefer tools that people quietly continue using over software that briefly performs interpretive dance on social media.

AI infrastructure · Programming languages · Coding agents · Knowledge representation · Long-context systems · Scientific computing · Developer tooling · Local-first software

Rust · Python · TypeScript · C++ · SQLite · PostgreSQL · FastAPI · PyTorch · CUDA · WebGPU · Docker · Linux

The systems above represent the core of my current work.

Beyond them, I maintain projects spanning:

• scientific computing
• data visualization
• simulation
• encryption
• retrieval systems
• execution environments
• CLI tooling
• research infrastructure

Most began as tools I built for my own work.

Many are now used by people I have never met, which is both flattering and a mildly alarming amount of responsibility.

Browse everything: github.com/andrewrgarcia?tab=repositories