r/VibeCodedLanguages • u/gmbasic • 2d ago
GMBasic is now open source β A modern compiled BASIC with native AI/LLM integration
r/VibeCodedLanguages • u/antonation • May 23 '26
Hey everyone, I'm u/antonation, the founding mod for r/VibeCodedLanguages.
This is a home for all things related to developing programming languages and compilers using AI.
What to Post
Post anything that you think the community would find interesting, helpful, or inspiring. It could your progress, your workflow (MCPs, testing frameworks, etc.), or questions if you're looking to get started.
Community Vibe
This is a friendly, constructive, and inclusive space. I believe AI is here to stay and welcome AI-driven development (which is of course, why you're here).
How to Get Started
Thanks for joining and I hope we can all learn from each other.
r/VibeCodedLanguages • u/gmbasic • 2d ago
r/VibeCodedLanguages • u/dyanos • 9d ago
Hi! Someone suggested I share this here. Tessera is an experimental, tensor-first language for numerical computing and data analysis. It compiles to native code through LLVM, and it was built by me together with AI coding agents.
GitHub: https://github.com/dyanos/csec-
(The repo name csec- and the compiler binary csec++ are historical names; the language is Tessera.)
external functions, and the early LaTeX-style math syntax.// Tensors are a core type, with the shape in the type
def affine(x: Tensor<Double, 1, 3>,
w: Tensor<Double, 3, 2>,
b: Tensor<Double, 1, 2>): Tensor<Double, 1, 2> {
return (x @ w) + b;
}
// Strict-by-default ownership: explicit move `<-` and borrow `&`
val acct: Account = new Account(100);
peek(&acct); // borrow, acct still usable
close(<- acct); // move
// using acct now -> compile error: "use of moved value 'acct'"
// Erlang-style microthreads
import std.microthread
def main(): Int {
val parent = self();
val worker = spawn([=]() -> {
val n = receive();
send(parent, n * 2);
return 0;
});
send(worker, 21);
return receive(); // 42
}Other features: arbitrary-precision Nat, built-in Complex/Rational/Quaternion, a symbolic algebra module, async/await, OS threads with channels, pipes, shared memory, and [@DllImport] for calling native libraries. A parallel wc -l written in Tessera runs at about 92% of a hand-written C++ mmap+SIMD version.
It's experimental. Right now I'm working on performance, starting with std.dataframe. The tensor codegen is still the first, straightforward version: shapes are read at runtime instead of being used at compile time, there's no loop fusion, and some temporaries aren't freed yet. Fixing that is next.
Thanks for reading!
r/VibeCodedLanguages • u/kindredseer • 29d ago
r/VibeCodedLanguages • u/kindredseer • Oct 16 '26
r/VibeCodedLanguages • u/kindredseer • Oct 12 '26
r/VibeCodedLanguages • u/Fit-Dragonfly2899 • Oct 12 '26
I'm designing a statically compiled programming language called Jeti. Its syntax is inspired by Objective-C, and its compiler translates Jeti source code into C99 before compiling it with Clang.
One of my design goals is to preserve Objective-C's recognizable syntax while introducing modern language features. I also want Jeti to remain a strict superset of C99, so existing C identifiers should ideally remain valid in Jeti code.
I'm currently unsure how to decide which new language features should use an @ prefix and which should use ordinary keywords.
Jeti retains several Objective-C constructs:
@ interface and @implementation for class declarations and implementations.@ property for properties.@ protocol for protocols.@ selector for selectors.@ try, @ catch, @ finally, and @ throw for exception handling.@ autoreleasepool for autorelease pool management.It also introduces new features with different syntax conventions:
async appears in return-type positions, as in - (async int)fetchUser:(int)uid;.await is a prefix operator, as in await [self fetchUser:uid].@ throws(NPString *) declares the exception types a method may throw.@ defer { ... } introduces deferred execution.@ namespace, @ using, and @ endnamespace provide namespace-related functionality.@ noarc { ... } marks a region where ARC is disabled.case with forms such as case NPString *s: and case > 100:.Box<NPString *>, with constraints such as T : Proto.This leaves me with a mixture of ordinary keywords and @-prefixed constructs.
One possible principle is to distinguish features by their grammatical role.
Features that occupy existing grammatical positions could use ordinary keywords. For example, async modifies a method's return type, while await acts as an expression operator.
Features that introduce new language constructs could use the @ prefix. For example, @ defer introduces a new statement-like construct, and @ namespace introduces a new declaration construct.
However, I'm not sure whether this is a meaningful and consistent distinction or merely an arbitrary convention.
Design A: Keep the current mixture
Use async and await without @, but retain @ throws.
For example, a method declaration would use - (async int)fetchUser:(int)uid @ throws(NPString *);, and an asynchronous call would use await [self fetchUser:uid].
The advantage is that async fits naturally into the return-type position, and await reads naturally as an expression operator. However, @ throws looks inconsistent with the other two features, even though all three belong to the same general family of asynchronous and error-handling functionality.
Design B: Use ordinary keywords for all three
Use async, await, and throws without @.
For example, the method declaration would be - (async int)fetchUser:(int)uid throws(NPString *);, and the asynchronous call would be await [self fetchUser:uid].
This provides consistent spelling for the three features, but it raises questions about how they fit into Objective-C-inspired syntax and whether they conflict with existing C identifiers.
Design C: Use the @ prefix for all three
Use @ async, @ await, and @throws.
For example, the method declaration would be - (@async int)fetchUser:(int)uid @ throws(NPString *);, and the asynchronous call would be @ await [self fetchUser:uid].
This gives the three features a consistent visual convention and avoids treating their names as ordinary C keywords. However, @ async in a return-type position looks unusual, and @ await as a general expression operator may feel less natural than @await.
The C99 compatibility requirement complicates this decision.
If @async, @await, or @throws becomes a reserved keyword, existing C code that uses one of those words as an identifier may no longer be valid Jeti code. Using @async, @await, and @throws avoids that particular conflict because the @ prefix distinguishes these tokens from ordinary C identifiers.
On the other hand, requiring the @ prefix for every new feature may make the syntax less natural, especially when a feature occupies an established grammatical position.
It may also be possible to use context-sensitive parsing or another mechanism to preserve existing C identifiers, but I'm not sure whether that would be a good language-design choice.
@ prefixes for features that introduce new constructs? Or is this distinction too arbitrary to be useful?async, await, and throws all use the @ prefix for consistency with one another and with Objective-C's existing exception-handling constructs, or is it reasonable to treat them differently based on their grammatical roles?async, @await, and @throws be preferable to ordinary keywords, or would context-sensitive parsing be a better solution?I'm interested in both the consistency of the language's syntax and the practical consequences for parsing, compatibility, and readability.
Jetiβs source code and development are available on GitHub: https://github.com/3shine123/jeti-lang
Iβd especially appreciate input from experienced Objective-C developers, particularly those who are also familiar with a modern high-level language that supports async/await. π
r/VibeCodedLanguages • u/kindredseer • Oct 11 '26
r/VibeCodedLanguages • u/kindredseer • Oct 09 '26
r/VibeCodedLanguages • u/antonation • Oct 08 '26
Hey everyone,
I've been building Sharpy ( https://github.com/antonsynd/sharpy ) for over a year now (wow time flies, and so does technology). I admit, even with AI, I haven't gotten as far along as I had planned (still far from 1.0). The major thing I spend my time on is fixing bugs. Occasionally, I have to convince Fable/Opus to let me do the fun stuff (new syntax, etc.).
Anyway, with the recent uptick in AI-driven game development, recomps, decomps, you name it, I decided I'd try my hand at having Claude vibe code a game for me. After trying it out (2-shot, with three.js https://github.com/antonsynd/zero ), I decided to dogfood my own language in Unity.
Some history, I started Sharpy because I didn't want to code in C# to make a Unity game. Honestly, in the time it took me to build Sharpy, I could've learned C# and had actually made the game in that time (I think).
Anyway, I let Opus build out a slice of Pokemon Heart Gold Soul Silver here: https://github.com/antonsynd/pokemon-sharpy with the help of a Unity plugin tailored for Sharpy https://github.com/antonsynd/sharpy-unity .
I quickly learned that I had even more bugs to add to my backlog. Some are related to how Sharpy resolves symbol names (it mangles Pythonic snake_case to C# PascalCase for interop), some are related to drift in compiler options (single file vs. project), etc. As such, Claude had to find workarounds, and I made it create an ideal version of the source code as the goalpost that we'll eventually reach.
Anywho, while I think it's cool to 1-shot or X-shot a language, the real tests come from the typical actions: self-hosting being one of the big ones, and dogfooding.
Curious to see how other people find bugs in their languages. I also hear that a trendy thing these days is to formalize your implementation or language and use a theorem/proof solver to verify the implementation, like using Verus, LEAP, or TLA+.
r/VibeCodedLanguages • u/cs61bredditaccount • Sep 30 '26
declint (docs) is a tool for making your own lint rules in YAML β the house rules that stock linters will never ship.
For instance: your AI model added except Exception: pass, and you want to know whenever that happens:
rules:
- id: except-pass
pattern: 'except Exception:\\s\*pass'
severity: warning
message: 'swallowed exception'Rules are just regex and a message. When a regex can't express the check, there's a Lua escape hatch β vetoes, whole-file analysis, absence rules ("every Dockerfile needs a HEALTHCHECK").
Rules run in your CI (inline PR annotations via --format github) and in your editor through LSP (declint.nvim for Neovim). Every rule can carry embedded fixtures, and declint test runs them β so AI-written rules come with their own spec.
Install: cargo install declint. Ships with presets (Python, INI, Markdown, shell, Dockerfile, TOML, JSON, JS) and community rulesets you can pull with one line. Feedback welcome, especially brutal takes on the YAML format.
r/VibeCodedLanguages • u/miku_claus • Sep 29 '26
Hey everyone!
I wanted to share an ongoing language design project Iβve been building: VBX (Visual Basic X).
Instead of a one-shot prototype or another interpreted toy running inside Python, the goal was to build a real, production-capable procedural language that compiles to standalone native binaries with zero runtime dependencies.
Compiler Host (Go) -> Target (C99):
-O2 optimizations.Solving the Runtime Memory Problem (Ring-Buffer Pool):
s = s & "x") typically floods malloc without high-level deallocation.vbx_alloc_str with 256 rotating slots of 4KB) directly in the emitted C runtime. Tested under 10,000 continuous iterations with zero heap leaks and flat memory usage.Language Syntax & Semantics:
Dim, Const, If/ElseIf/Else, For/Next, While/Wend, Do/Loop, Select Case (supporting both string and numeric comparisons natively via chained branches), Sub, Function, and 1D fixed arrays.MsgBox, InputBox), standard File I/O, and string manipulation routines.Testing & Tooling:
go test ./....vbx-studio).Repository: https://github.com/M5Devs/vbx Editors: https://github.com/M5Devs/vbx-editors
Would love to discuss the language design trade-offs, transpiler architecture, and experiences building full-scale compilers using modern agentic workflows!
r/VibeCodedLanguages • u/VermicelliSmooth1183 • Sep 29 '26
r/VibeCodedLanguages • u/kindredseer • Sep 27 '26
r/VibeCodedLanguages • u/VermicelliSmooth1183 • Sep 21 '26
r/VibeCodedLanguages • u/kindredseer • Sep 21 '26
r/VibeCodedLanguages • u/Pattinathar • Sep 12 '26
I've been building a language where a function's signature declares which effects it may perform, and a runtime refuses anything outside a budget you grant. The obvious question is whether that catches anything real, so I built a benchmark.
63 programs β 56 dangerous, 7 harmless controls β each written three times in Velaris, Python and JavaScript, doing the same thing. Eleven categories: effects hidden in helpers, division by user input, off-by-one reads, integer overflow, ignored failures, infinite loops, runaway memory, dangerous modules, scoped-budget escapes.
Results across the 56 dangerous ones β caught before running / during / missed:
Velaris 42 / 12 / 2. Deno 5 / 27 / 24. Python 0 / 28 / 28. Zero false positives on the controls for all three.
The first column is the interesting one. Deno's permission model works, it just works at the moment of the call β nothing in deno check or deno lint reads a file write as a problem.
What mine missed: one computes the wrong answer and promises nothing, so there's no contract to check against. The other prints the string rm -rf / β it doesn't run anything, and flagging it would mean flagging any program that prints text resembling a command.
And four cases where the prover fell short and only the runtime check caught it, named by ID in the write-up: a division on n - 1 with n from a checked parse, the same on an unguarded path when another path guards it, a remainder inside a loop body, and a read at i + 1 in a loop bounded by length(xs).
Full write-up, methodology and the reproduce command: https://dev.to/gowrishankar-dev/i-tested-my-sandbox-against-deno-and-plain-python-on-63-ai-written-scripts-1llp
r/VibeCodedLanguages • u/VermicelliSmooth1183 • Sep 10 '26
People here already know Nyx, so I won't do the usual language introduction.
I've been thinking about the project lately, and I've reached a point that I honestly didn't expect:
I'm not sure Nyx actually means anything anymore.
Not technically.
Technically, I know exactly what it is. I know the architecture, the HIR, the backends, the native interop, the direction I've been taking it, and what I could build next.
The problem is that I can't answer the more fundamental question:
Why am I building this?
I've spent a lot of time making Nyx more capable. Every time there was an interesting compiler problem, I solved it. Then another one appeared. Then another.
At some point, I stopped asking whether a feature served the original idea and started asking whether I could implement it.
That's been bothering me.
I don't think the project is technically pointless. There's a lot of interesting engineering in it, and I've learned a ridiculous amount from building it.
But I'm starting to wonder whether I've confused technical depth with purpose.
Nyx has a direction, but I'm not sure it has a reason.
And I don't want to solve that feeling by adding another backend, another language feature, another abstraction layer, or another ambitious subsystem. That would probably just make the same problem larger.
So I'm putting this here as an actual RFC, not as a roadmap proposal.
I want to figure out whether Nyx has a meaningful core idea that I've lost somewhere along the way, whether that idea needs to be redefined, or whether the project was fundamentally an engineering experiment that I've been trying to turn into something more than it needs to be.
For those of you who've followed Nyx for a while:
What do you think Nyx actually is?
Not what it currently implements.
Not what it could implement.
What do you think the project is fundamentally trying to accomplish?
r/VibeCodedLanguages • u/VermicelliSmooth1183 • Sep 09 '26
Iβve been working on the next stage of Nyxβs compiler architecture after v5.
Nyx already has a canonical Typed HIR and multiple output targets, but I donβt want every backend to slowly become its own slightly different interpretation of the language. The current work introduces a lower-level MIR between Typed HIR and the backends:
Nyx source
β
AST
β
Canonical Typed HIR
β
Verified MIR
β
Target legalization
β
C++ / LLVM / Wasm / Rust / JavaScript / Python / C17This is being developed with heavy agent assistance, so Iβm deliberately separating implemented and tested work from architectural plans.
What is currently implemented:
break, continue, strict evaluation order, wrapping 64-bit arithmetic and division traps.defer cleanup chains, Result propagation with ?, guards, ranges, match lowering and try/catch/throw edges.The completed milestones have focused regression suites, including execution through a reference MIR interpreter and selected C++/LLVM oracle comparisons.
What is not finished:
The detailed architecture document explains the representation boundaries, layout model, ABI plan, legalization rules, migration order and later language-surface work:
https://github.com/justsomeone-e/nyx/blob/main/docs/internals/NYX_DEEP_COMPILER_ARCHITECTURE.md
Iβd especially appreciate feedback on three questions:
Iβm interested in criticism of the actual contracts and failure modes, not just the number of planned backends.