r/VibeCodedLanguages • u/kindredseer • Aug 23 '26
madc v0.95.2 released โ faster startup, faster FP code, and less ceremony
r/VibeCodedLanguages • u/kindredseer • Aug 23 '26
r/VibeCodedLanguages • u/kindredseer • Sep 21 '26
r/VibeCodedLanguages • u/VermicelliSmooth1183 • Sep 07 '26
r/VibeCodedLanguages • u/lfnoise • Sep 05 '26
r/VibeCodedLanguages • u/VermicelliSmooth1183 • Sep 04 '26
Hey everyone,
First off, huge thanks to everyone who checked out the repo, left comments(No one did ngl), and starred the project(2 Stars still thanks!) after my previous post. The feedback and discussions around systems language trade-offs were genuinely invaluable.
I'm currently designing and mapping out Nyx RC.2, with a heavy emphasis on making WebAssembly a first-class, seamless target rather than just an afterthought backend.
Zero-friction TypeScript / JS Interop: When compiling to Wasm, the compiler will automatically emit .d.ts type definition files alongside the .js glue wrapper, allowing Nyx Wasm modules to be imported directly into React/Next.js/Node projects with full IntelliSense.
Deterministic Memory & Cleanup: Continuing to refine the Typed HIR pipeline so that linear memory allocation, defer, and RAII semantics remain memory-safe without requiring a heavy runtime or a complex borrow checker.
Cross-Platform Tooling & "Tour of Nyx": Refactoring our interactive terminal learning suite (tour) to be fully portable across Windows, macOS, and Linux without environment assumptions.
Web / DOM Bindings Exploration: Exploring minimal, zero-overhead DOM and WebGL/WebGPU hooks directly from the language.
For those who work with Wasm or build compilers: What is currently the most painful part of your Wasm workflow that you wish a language solved out-of-the-box?
Are there specific language ergonomics, stdlib modules, or tooling features you'd love to see in RC.2?
Any edge-cases or architectural pitfalls in Wasm/C++20 lowering I should watch out for?
Repo is available here if you want to inspect the current codebase: https://github.com/justsomeone-e/nyx
Appreciate any critiques, feature requests, or sanity checks!
r/VibeCodedLanguages • u/VermicelliSmooth1183 • Sep 02 '26
It will be useful I promise
r/VibeCodedLanguages • u/kindredseer • Aug 20 '26
r/VibeCodedLanguages • u/gusfromspace • Aug 19 '26
r/VibeCodedLanguages • u/med_i_terranian • Aug 07 '26
I have been working on this language since May. Its heavily inspired by Strudel and partially by SuperCollider. It works as many things all at once. It is a music sequencer, synthesizer, fx box, generative music (conditional statements, if, else) and sample mangling (need non-browser version for that), automation, per note automation, recursion, easy nesting of gradually more complex sequences/fx/etc.
If anyone wants to try the language, its here, https://quadracollision.com/mescript/ mostly usable in browser unless you want to use samples, if so just let me know.
As for tools: This is GPT 5.3 -> GPT 5.4 -> GPT5.5 -> GPT 5.6 Sol, all Medium. This is Rust+WASM with a Javascript front end. No external libraries
This is an example of MeScript in action: you can paste this into the editor and it'll work.
Check CTRL+H for insertable smart forms, cursor position defines how the form is inserted. Also check out the language reference guide. There is also a repl, place the cursor on any line and right click and press parameter help and it will explain what the line does. Also (fix-parens linenumbers) (fix-parens 15-17) can help with parenthesis issues, this is a Lisp inspired language.
(def am [as d f]) ;this is a chord form, asharp d and f
(ins :saw ;this is an (ins)rument form
:src [:saw-synth :square-synth :additive] ;these are the oscillators that make up this instrument
:note (p (times 4[c4 0 c5 0 e3 c3 e3]) ;these are the note gates and how many
(times 4[c4 0 c5 0 e3 c3 eb3])) ;times they play
:gate nil
:fx [(formant :vowel a :mix 0.2)] ;fx applied to entire instrument
:dur nil ;duration of each gate hit, can be per hit as well
:amp nil ;amplification of instrument, can be per hit and automated conditonally
:voice nil) ;special keyword, see ctrl+h for voice commands, as well as everything else
(def chord_1 [c4 eb4 f4 gb3])
(ins :kick
:src :kick-synth
:note (p [c4 0 0 0 c4<?50> 0 0])
:gate nil
:fx nil
:dur nil
:amp nil
:voice nil)
(ins :hat-808
:src :hat-808
:note (p [c7 c7 <c4%c5%c7> 0 c7 <c7%e5%b4%g5> c7 am(3 3 3)]) ;this calls the chord form with each note being an octave of 3
:gate nil
:fx nil
:dur nil
:amp nil
:voice nil)
(ins :snare-808
:src :snare-808
:note (p [c4<?30> 0 0 c4<?50> 0 0 0 0])
:gate nil
:fx nil
:dur nil
:amp nil
:voice nil)
(ins :pad-wash
:src :pad-wash
:note (p [chord_1<_7> 0 0 0 0 0 0 0])
:gate nil
:fx nil
:dur nil
:amp 0.05
:off true
:voice nil)r/VibeCodedLanguages • u/antonation • May 28 '26
Here it is: https://github.com/antonsynd/sharpy
You can also try the transpiler to C# in the browser without installing anything: Try Sharpy Online (Blazor WASM playground).
I'm one of those people who wants to work on something, and then ends up building something to work on that something, which is completely unproductive. In this case, I wanted to make a game in Unity, but I didn't want to use C# 'cause reasons. I figured, why not create a Pythonic language that transpiles to C#? The object model and memory models are similar enough. (I had an earlier attempt to do the same but targeting C++ for a separate reason, but I quickly ran into hard decisions about wrapping everything in shared_ptr's and things looking kind of awful).
I'm aware that Boo was a thing, but one of the things that irked me about it was the retention of PascalCase access to .NET APIs. For a Pythonic language, access to .NET should look Pythonic.
There is a compiler (using Roslyn), a standard library of the Python modules you expect most: json, os, re, numpy (sort of), sqlite3 (sort of), requests (sort of), itertools, etc., a language server with a VS Code extension, and support for multi-file projects via *.spyproj files (akin to *.csproj files).
Sharpy is statically-typed, so no dynamic features are available (yet, or maybe ever). However, there are some things that make static typing more ergonomic:
x = 5 # obviously an `int`, specifically `int32`
# (`int` is an alias)
x: str = str(x) # reassignment with a type annotation is shadowing
x: auto = [x] # `auto` type infers and simplifies the type
# annotation for cumbersome types. here it is
# inferred to be `list[str]`. this also shadows.Sharpy supports nullable types AND true optionals. Nullable types are annotated as T | None, and optional types are T?. The reason both exist: .NET APIs return nullables, so Sharpy needs to interop with those, but for Sharpy-native code, true optionals (tagged unions under the hood) are safer and pattern-matchable. T? gets the short syntax because I wanted to promote optionals as the default choice. Null-aware operators work on both, e.g. ?. (safe navigation/optional chaining) and ?? (null-coalescing).
To make working with .NET and nullable APIs easier, you can use maybe in front of a nullable expression to auto-wrap the expression value in a true optional:
x: int | None = some_function_returning_nullable_int()
y: int? = maybe some_function_returning_nullable_int()
match y:
case Some(v):
print(v)
case None():
print("no value")Sharpy also has a result type, with a similar keyword try for auto-wrapping throwing expressions in the result type, with optional type annotation to change the exception type in the result.
x: str !Exception = try some_throwing_function()
y: int !ValueError = try[ValueError] int(x.unwrap_or(""))Since Sharpy has both true optionals and result types, Sharpy predictably has ADTs/tagged unions (a la Rust):
union HttpResponse:
case Success(body: str, status_code: int)
case Redirect(location: str, permanent: bool)
case ClientError(message: str, code: int)
case ServerError(message: str, code: int)
def categorize(response: HttpResponse) -> str:
match response:
case Success(body, status_code):
return f"ok: {body}"
case Redirect(loc, permanent):
return "moved" if permanent else "found"
case ClientError(msg, code):
return f"error {code}: {msg}"
case ServerError(msg, code):
return f"server error {code}: {msg}"As mentioned before, I believe access to .NET APIs and other PascalCase libraries should be Pythonic looking. So, there is name mangling of symbols to PascalCase for lookup:
from system import Console # Note lowercase namespace
def main():
Console.write_line("Hello World!") # Note the snake_case
print("Hello World!") # You can also just do this,
# don't worryThe compiler preserves original CLR names through the discovery pipeline, so interop just works: you write snake_case, the generated C# uses the correct PascalCase name, and the .NET runtime sees what it expects.
For cases (har-har) where you don't want name mangling to occur, you can use backticks to block this and let the compiler treat the symbol name as you wrote it:
from `System.Collections.Generic` import HashSet
def main():
h = HashSet()Leading underscores on type members and methods lead to default access levels being applied. _foobar defaults to C# protected, and __foobar defaults to C# private. You can override this by using the associated access modifier "decorator"/attribute:
class Foobar:
_something_protected: int
__something_private: str
@public
__something_public_because_of_decorator: bool
@private
_something_private_because_of_decorator: float
# Exception: dunders are public by default
def __init__(self):
passDunder methods exist in Sharpy, but they are not real methods. Instead, they are treated by the compiler as an instruction to generate another method(s) to fit in the .NET ecosystem. Some are obvious like, __init__ is a constructor, whose body becomes the constructor's body, and __str__ becomes public string ToString().
Others are not as obvious like operators which create static operators (because that's how they work in .NET's runtime), __enter__ and __exit__ for context managers map to a compiler-generated C# IDisposable implementation, etc. Some are flat out not supported like __pow__ because ** is not an operator nor is it an overloadable method in .NET.
This was tough to reconcile, but I think I landed on something that is acceptable without being too jarring for Python developers.
Sharpy has a built-in @test decorator that maps to xUnit under the hood. You write tests that look like pytest, and the compiler emits [Fact], [Theory], [InlineData], and xUnit lifecycle plumbing:
@test
def addition_works():
assert 1 + 1 == 2
@test.parametrize([(1, 2, 3), (4, 5, 9)])
def addition_parametrize(a: int, b: int, expected: int):
assert a + b == expected
@test.skip("not implemented yet")
def todo_test():
passThere's also @test.fixture for shared setup/teardown and @test.collection for grouping.
The standard library has 31 modules. Some highlights:
numpy: NdArray[T] with broadcasting, slicing, linalg, FFT, and random (backed by Math.NET Numerics)
sqlite3: Connection, Cursor, Row with parameterized queries
requests: Python-compatible HTTP API
json: typed deserialization with json.loads[T](), custom encoders/decoders
re, os, itertools, functools, collections: the usual suspects
15 of these modules are themselves written in Sharpy (.spy files compiled to .dll).
There's a bunch of stuff in here, it's a bit much to write about exhaustively. Some quick hits:
Late-bound defaults (PEP 671): def f(x, y => len(x))
@lru_cache / @cache: compiler-innate functools memoization
Source generators: user-defined compile-time code generation
Inline out declarations: out name: type for .NET interop
Incremental compilation: content-hash caching with transitive dependency tracking
I hope you'll play with it and look at the file-based integration test fixtures for working examples. There's also a language server + VS Code extension (not submitted to the marketplace yet, but you can load it locally) with syntax highlighting, doc/type on-hover tooltips, inline argument names, rename support, go-to-definition, and semantic token highlighting. There are probably bugs in the highlighting and stuff, but it works enough to make me happy.
Honestly, if it wasn't for Claude, this project would've taken me at least 3 years, optimistically. I didn't use AI in the beginning; I hand-wrote a chunk of the standard library, tried to write the parser with ANTLR, and so on, but I got impatient and ran into tougher parts of the compiler that discouraged me. So almost a year later, I leaned into AI-accelerated development with some guardrails: a hand-written language specification, three axioms that govern almost every design decision (modulo my personal preference), and a growing suite of file-based integration test fixtures and property tests.
I think of my role as the "orchestrator", deciding what the language should be, writing the spec, reviewing the output, and steering corrections. Yeah, I didn't learn the nitty gritty of writing a compiler or language server, but it left me room to think about higher-level language design: do these features make sense, do they compose well, do they feel right? I know not everyone in the compiler/programming language space is happy with this direction, but I feel a lot more empowered to implement ideas this way.
The implement-eval/test loop is much faster, and you can validate ideas quickly. At the same time, without oversight, AI can take a language feature in a different direction or implement something narrowly. It's very difficult with the velocity and volume of code generation to keep up as a solo human reviewer. The spec and axioms help, but I'll be honest, there's a degree of blind faith that AI-generated tests aren't hiding poor decisions in the actual implementation. I guess I'll find out when I actually use it for my Unity game.
Unity plugin: hooking the Sharpy compiler into the Unity build flow, which was the whole point of this project
Rounding out the stdlib: filling gaps in existing modules, potentially adding more
Actually making the game lol
Hope this has been educational, happy to answer any questions!
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
Introduce yourself in the comments below.
Post something today, anything you're working on, challenges you run into, etc.
If you know someone who would love this community, invite them to join.
Interested in helping out? I'll be looking for additional mods at some point, so feel free to reach out to me if you're interested.
Thanks for joining and I hope we can all learn from each other.
r/VibeCodedLanguages • u/dyanos • 3d 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.)
Me, by hand (late 2024 to early 2026): the language concept and design, the first lexer and parser, the AST, LLVM IR generation, constructors, C++ name mangling, external functions, and the early LaTeX-style math syntax.
OpenAI Codex: the native runtime, tensor and simulation features, native library interop, templates, and the first self-hosting bootstrap.
Claude (Claude Code): the ownership and move checker, async/await, Erlang-style microthreads, most of the standard library, support for LLVM 18 through 23, Parquet/CSV data frames, and import aliases. About 110 of the ~200 commits are co-authored with Claude.
Tests are the real spec. The agents are very productive but will confidently break things. I keep positive and negative fixture suites, ownership suites, and concurrency and stdlib tests, and the same suites run through two compilers: the C++ one and a self-hosted one.
Self-hosting is a great lie detector. A second compiler written in Tessera has to compile itself and reproduce the same output (a fixed point). A codegen bug the agent "fixed" often shows up only one stage later, and the fixed-point check catches it.
My job changed. I went from writing code to deciding semantics, reviewing diffs, and designing verification. Design decisions such as strict-by-default ownership and tensors as a core type stayed with me. The agents were best at the large, well-specified implementation work.
Agents make the same subtle mistakes repeatedly. Examples are an LLVM API that changed behavior silently between versions, and build tools that didn't notice changed header files. Writing these down as project notes for the agent helped a lot.
// 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.
How do you verify AI-written compiler code? Do you use self-hosting, differential testing, or something else?
Where do you keep design authority, and where do you let the agent decide?
Thanks for reading!
r/VibeCodedLanguages • u/kindredseer • 23d 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.
Pattern matching extends case with forms such as case NPString *s: and case > 100:.
Generic types use forms such as 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.
Is there a principled reason to distinguish new features by grammatical role, using ordinary keywords for features that fit existing grammatical positions and @ prefixes for features that introduce new constructs? Or is this distinction too arbitrary to be useful?
Should related features use the same spelling convention? In particular, should 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?
Are there useful precedents in Objective-C or other languages for deciding when a language extension should introduce a new keyword versus a specially prefixed construct? I'm particularly interested in examples involving new statement or expression syntax, rather than declaration annotations or attributes.
What is the best way to preserve strict C99 compatibility while adding features such as asynchronous functions and exception specifications? Would prefixed forms such as @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 09 '26
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):
The compiler itself is written in pure Go without external packages, leveraging the standard library for AST construction, multi-pass type inference, and process orchestration.
Emits clean, standard C99 code and invokes the system toolchain (GCC/Clang) with -O2 optimizations.
Solving the Runtime Memory Problem (Ring-Buffer Pool):
Naive transpilation of string operations inside tight loops (s = s & "x") typically floods malloc without high-level deallocation.
We implemented a fixed static ring-buffer memory pool (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:
Visual Basic-inspired syntax: 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.
Built-in primitives: Native OS dialogs (MsgBox, InputBox), standard File I/O, and string manipulation routines.
Testing & Tooling:
42 integration and unit test suites running via go test ./....
Complete multi-editor support repository: official VS Code extension (available on Visual Studio Marketplace), plus packages for Sublime Text, JetBrains, Vim/Neovim, Notepad++, Emacs, and Micro.
Currently designing Phase 2: a dedicated desktop IDE with a visual form designer (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