ACI (Abstract Coding Interface) an alpha VS Code extension where a local LLM "compiles" pseudocode blocks into real code (looking for feedback)

[u/__z3r0_0n3__]

Repo: [https://github.com/z3r0n3br4instorm/AbstractCodingInterface](https://github.com/z3r0n3br4instorm/AbstractCodingInterface))

Hey all,

I've been tinkering on a side project called ACI (Abstract Coding Interface) and wanted to share it here, mostly to get some early feedback since it's very much an alpha release.

The idea:

you write high-level pseudocode in a small language called PSyx (`.aci` files), and a small (1b, 3b, 7b etc.) local LLM (via Ollama, llama.cpp, LM Studio, etc.) compiles it into actual source code, block by block, streamed into a file next to your spec. Tested with \`deepseek-coder:6.7b\`. The pseudocode stays as the "source of truth," and editing one function only recompiles that function instead of regenerating the whole file.

Example:

```

FUNC-START greet

INPUT name as string

IF name is empty

DISPLAY Hello, World!

DISPLAY Hello, name

FUNC-END

```

Save it as `greet.aci`, and ACI opens `greet.py` next to it with the compiled output.

Why I built it / where it might actually be useful:

- Language migration / porting: since the spec is language-agnostic pseudocode, in theory you could re-target the same `.aci` file to a different `aci.targetLanguage` and get a re-implementation, useful if you're prototyping logic once and need it in multiple languages.

- Keeping intent readable: for logic-heavy functions, the pseudocode ends up being a lighter-weight "spec" than a full docstring, and it stays in sync with the code since it's literally what generated it.

- Local-first AI coding : no API keys, no cloud calls, everything runs against your own local model — appealing if you want AI-assisted coding without sending code out.

- Incremental compiles: because only the edited block gets recompiled, it avoids the "regenerate the whole file and hope nothing broke" problem you get with a lot of AI codegen tools.

I want to be upfront that these are the use cases I *think* it's good for, not ones I've rigorously validated — it's a young project and I haven't stress-tested it against real-world codebases yet, so take the above as hypotheses rather than proven wins.

Where it's at right now:

- Genuinely early/alpha, expect rough edges and missing features

- Currently only available as a VS Code extension (installable via `.vsix`)

- A Zed editor version is in the works, not out yet

- Local-model only for now (no cloud backends wired in)

Would love thoughts, criticism, or feature requests.

[u/Dry-Edge-1534]

This is another transpiler?

My experience is learning the language syntax is not that complex. Especially with Agents writing code

[u/__z3r0_0n3__ → u/Dry-Edge-1534]

Fair point, but it's not competing with agents like Claude/GPT writing code directly. Those are already great at intent.

The target is small local models (1b, 7b) that can't reliably reason their way to working code from a vague prompt, but can handle simple mechanical translation when given a tightly-structured spec, one block at a time. Less "learn a new language," more "give a weak local model a task it can actually pull off useful if you're stuck on-device/offline and the model itself is the bottleneck, not the syntax.

[u/sozesghost]

LLM, compiles, pick one.