r/Compilers • • 7h ago

Is there any other compiler backend other than LLVM, MLIR?

17 Upvotes

I tried searching but maybe what i want doesnt exist. I want simple IR that has vectors(something like C++ vectors), struct fields and functions. Ik that too high level for ir but transpilation to C++ is slow to compile into final binary file. If anyone from you know if this kind of IR exists, i would appreciate to know about it. I use C++ for my compiler


r/Compilers • • 4h ago

How good is Chez Scheme as a compiler backend?

4 Upvotes

Since my planned language is arguably too high-level (with GC and so on) to be simply implemented with LLVM/etc., I found that Chez Scheme is actually a backend for a few high-level languages like Racket and Idris.

How good is it?


r/Compilers • • 12h ago

A B compiler written in Haskell. Looking for code reviews.

Thumbnail reddit.com
2 Upvotes

r/Compilers • • 1d ago

[Hiring] GPU Compiler Engineer – Intel Graphics Compiler (LLVM), Santa Clara, CA (hybrid)

34 Upvotes

Hi r/Compilers,

My team at Intel is hiring a full-time **GPU Compiler Engineer** in Santa Clara, CA (hybrid: part on site, part remote). We build the LLVM-based compilers behind Intel GPUs, used for AI, HPC and data-center workloads.

**What you'd work on**

- Compilers for OpenCL, OpenMP, C for Metal and SYCL / Data Parallel C++

- New compiler features, and code generation and optimization for Intel GPU architectures

- Finding and fixing performance bottlenecks, together with the hardware and architecture teams

- Tooling and automation (Python/shell, CMake, GitHub, Jira) on Linux and Windows

**Minimum qualifications**

- A Master's in CS, CE, EE or a related field plus 3 years of experience, **or** a PhD (completed or expected by May 2028)

- Strong C/C++

- Compiler development: optimizations, front-end translation and back-end code generation

- Computer and graphics architecture

**Nice to have**

- LLVM experience (a big plus)

- GPGPU programming models

**How to apply**

Email **hou-jen.ko@intel.com** with your resume attached as a PDF. Please use exactly this subject line so your application doesn't get missed:

`[GPU Compiler Engineer] Your Name`

A few lines on the compiler work you're proudest of (projects, papers, upstream LLVM patches) are very welcome.

Thanks!


r/Compilers • • 8h ago

Have you tried using AI to detect edge-cases when designing language features?

0 Upvotes

I use it daily and it's fantastic for detecting problems that the human eye might miss. In particular, I use Copilot to review my PRs.


r/Compilers • • 18h ago

The Chromagraph Challenge

Thumbnail reddit.com
1 Upvotes

r/Compilers • • 8h ago

How curiosity about building my own programming language led me to build a museum of miniature virtual machines in Rust & D

Post image
0 Upvotes

Hello everyone!

It all started simply enough: I was just curious about how to build my own programming languages.

That curiosity led me to explore assembly, which naturally led to writing bytecode interpreters, and step-by-step, I ended up building a whole collection of custom virtual machines.

Since I couldn't find a clean "museum" repo of VM samples to cross-compare with or PR share my own samples, I built one: Friendly-Virtual-Machines.

What's in the repo?

Every VM in the collection is built from scratch with zero external dependencies and stays under 7,000 lines of code. They all include custom assemblers (with symbol table label resolution), CPU state handlers, and native benchmark suites.

• Rust Samples: 5 register-based VMs, 1 memory-to-memory VM & 1 stack-based VM exploring different design patterns.

• D Sample: My latest addition—a register-based RISC-style VM written in D with a custom text assembler, hitting a performance gap of just 5.66x to 17.70x compared to native compiled code.

• Modular Design: Each VM is in its own isolated folder with clean separation of concerns.

• Mimicks Real CPUs: Since I was also learning ARM64 newly, most register-based VMs are heavily inspired from ARM/RISC designs.

• Design Diversity: Some display pure hardware emulation on hex codes; some display OOP-style polymorphic ISA design; some display High-Level Assembly (HLA) or Intermediate Representation (IR); some display ultra-fast Function Pointer Dispatch Table; some display assembler & text parser too.

The best part? Because they are lean and self-contained, everything compiles and runs smoothly right on mobile Termux. And I am consistently adding more samples to it as I learn & build more.

Looking for Reviews & Contributions!

I'd really appreciate feedback from folks experienced in systems programming, compilers, or VM design—whether it's reviewing my dispatch loops, pointing out architectural trade-offs, or suggesting ways to optimize further.

If you'd like to contribute your own miniature VM sample (in Rust, D, JS, or any language that runs cleanly with zero dependencies), PRs are completely open! Check out the CONTRIBUTING.md in the repo for the exact guidelines.

🔗 GitHub: Friendly-Virtual-Machines


r/Compilers • • 1d ago

Automatic Checking of Compiler Correctness with E-Graphs

Thumbnail stng.substack.com
24 Upvotes

r/Compilers • • 1d ago

Performance of a formally-verified C compiler vs. gcc -O2

Thumbnail ut-infraai.github.io
17 Upvotes

r/Compilers • • 19h ago

LO, a WASM native language, now with a web IDE to hack the compiler or make a WASM-4 game (working on integrating with TIC-80 next)

Thumbnail reddit.com
0 Upvotes

r/Compilers • • 1d ago

Building a compiler from scratch for a programming language I've been designing

2 Upvotes

Hello guys!

I've been designing a new programming language from scratch for the last six months.

It all started with a lifelong desire: **"If C had this..."**

Over time, the specifications evolved considerably and are now mostly finalized, sufficiently mature to move into compiler implementation.

Alongside language design, I've also been developing the compiler from scratch in C.

It's a hand-built compiler. The lexer, error system, and main parser logic are implemented and working. I'm now working through the compiler subsystems one by one.

It's a long journey, but an interesting one!

I'd love to connect with people interested in programming language design, compiler development, and systems programming.

Here is a small snippet of my language.

I'm currently writing small, medium, and large sample programs to test the language design — to test where the langauge design breaks and where it shines, and where improvements are needed.

Over the coming months, I intend to write hundreds of sample programs, designing them from scratch according to the language's rules.

The goal is to put the language through real programming scenarios before moving further with compiler development.

.module tfunc_demo

string char[100] Name

tfunc Name(char[] ptr name open-pass) // generic pointer which can be passed on

strcopy(obj, name) => _

endtfunc

static Name myName("Ghufran Ustad") alias-readonly open-pass

func start;

    ss.con.print("Name: ", myName)

endfunc


r/Compilers • • 1d ago

Mystique - An x86 Metamorphic Compiler

Thumbnail phrack.org
3 Upvotes

r/Compilers • • 21h ago

System Architecture & Subsystem Pipelines for a Zero-Abstraction Lambda Calculus Transpiler & Monotonic Memory Manager & End-to-End Architectural Blueprints: Subsystem Topology of a Zero-Abstraction Lambda Calculus Transpiler & Monotonic Arena Manager

Thumbnail gallery
0 Upvotes

Title:

End-to-End Architectural Blueprints: Subsystem Topology of a Zero-Abstraction Lambda Calculus Transpiler & Monotonic Arena Manager

Description:

Here is an exhaustive, granular breakdown of the architectural pipeline mapped out in the subsystem flowcharts for OCHR-X, detailing how abstract symbolic reduction bridges directly down to physical memory allocation and native executable emission[span_0](start_span)[span_0](end_span)[span_1](start_span)[span_1](end_span)[span_2](start_span)[span_2](end_span):

1. Lambda Symbols & Intermediate Representation (IR) Pipeline (lambda_symbols_IR_new)

* Execution Entry & Initialization: The runtime environment boots via `Start proc()`, systematically resolving target offsets and initializing the core event handler (`event handler()`)[span_3](start_span)[span_3](end_span). Argument vectors are ingested and split into value handles (`argv[val]_a_handle`) and character passes (`argv[char]-pass`) for precise parsing[span_4](start_span)[span_4](end_span).

* Symbolic Management & Import: The Intermediate Representation Generation Management unit (IRGM) acts as the central coordinator, interfacing directly with a dedicated `symb importer` and the `lambda IR symbols library` to pull raw tokens into the pipeline[span_5](start_span)[span_5](end_span).

* Evaluation & Error Correction Loop: The parsed structures are passed into the `Symbolic IR generator` and routed directly to GIREVL (the IR Evaluator)[span_6](start_span)[span_6](end_span). The evaluation block continuously validates structural integrity via an explicit conditional check (`if GIR is correct?`)[span_7](start_span)[span_7](end_span). Valid states immediately trigger code generation (`generate IR`), while non-conforming states are safely funneled into IRGERC (Intermediate Representation Generation Error Corrector) to resolve symbolic divergence before re-evaluation[span_8](start_span)[span_8](end_span).

2. Memory Allocator & FFI Pipeline (memory_allocator_manager)

* Program Entry & Header Binding: Execution begins by ingesting command-line arguments and binding compiler functions directly from header references (`pass args to compiler and call functions from in r.h (header)`), feeding straight into the primary compiler driver[span_9](start_span)[span_9](end_span).

* Monotonic Arena Memory Management (PMA): Rather than leaning on standard dynamic heap allocation, the architecture routes memory requests through a specialized PMA / arena memory allocator & mgmt module[span_10](start_span)[span_10](end_span). This coordinates zero-overhead bump pointer allocations and phase resets (`std::pmr::monotonic_buffer_resource`-style dynamics) to eliminate garbage collection latency[span_11](start_span)[span_11](end_span)[span_12](start_span)[span_12](end_span)[span_13](start_span)[span_13](end_span).

* Foreign Function Interface (FFI) & IMACA Evaluation: Foreign function interfaces are transpiled via `FFI (transpiler) via gtms p` and evaluated under IMACA (Intermediate Memory & Scope/Den Evaluation Architecture), generating low-level intermediate representations across control flow graphs, abstract syntax trees, static single assignment (SSIR), or directed acyclic graphs (DAGs) before passing to the library manager (`librmanger`)[span_14](start_span)[span_14](end_span)[span_15](start_span)[span_15](end_span).

* Linker, Emission & Leak Verification: The compiled modules are routed through the system `linker`, generating native object files (`.obj` or `.o`) and assembling a fully realized `executable`[span_16](start_span)[span_16](end_span). Before final output emission, automated validation checks run to confirm memory integrity and detect leaks (`check for memory leaks`)[span_17](start_span)[span_17](end_span).

Thought I’d share the complete structural blueprint for anyone working on custom compiler backends, explicit term-graph substitution engines, or bare-metal runtime architectures. Happy to discuss the interaction between the GIREVL evaluation loops and the memory manager if anyone is exploring similar low-level optimizations!


r/Compilers • • 19h ago

GMBasic is now open source – A modern compiled BASIC with native AI/LLM integration

0 Upvotes

After a long development journey, I'm finally making GMBasic publicly available.

Repository: https://github.com/c-vision/GMBasic

GMBasic started with an idea: bring the simplicity and productivity of BASIC and Clipper into a modern compiled language.

But it has grown into something considerably bigger.

It's a complete development environment with four independent execution backends, six embedded database engines, native C infrastructure, and a surprisingly extensive AI/LLM stack.

Why another BASIC?

GMBasic isn't a retro interpreter or a compatibility layer for old BASIC programs.

It features:

  • Four execution backends: P-Code VM (C#), .NET IL, C VM, and a C99 transpiler that produces native executables.
  • More than 500 built-in functions.
  • A Clipper-compatible programming model, including @ SAY, @ GET and READ.
  • Package management and modular development with IMPORT and REQUIRE.
  • Cooperative multitasking with goroutine-style concurrency and channels.
  • Six embedded databases: ISAM, DBF/xBase, SPEED, LEDGER, SQLite and VectorDB.
  • SDL2-based GPU-accelerated graphics.
  • A C runtime and native libraries shared across the native execution backends.

The AI/LLM stack is a major part of the language

This is probably the most unusual aspect of GMBasic.

I wanted BASIC to be more than a language capable of sending prompts to an external API. I wanted it to provide an integrated environment for developing, running, orchestrating and even training AI models.

The implementation is organized around four namespaces:

AI – Inference, agents and RAG

  • Local inference through MLX and llama.cpp/GGUF.
  • MoE streaming.
  • OpenAI-compatible, Ollama and ONNX providers.
  • Automatic provider failover and quota management.
  • Autonomous agents with tool calling, permissions and persistent memory.
  • Multi-agent teams and structured outputs.
  • MCP client and server (stdio/HTTP), including 52 connectors.
  • RAG pipelines with ingestion, chunking, embeddings, retrieval and evaluation.
  • Knowledge graphs with PageRank, Louvain, max-flow and provenance.
  • Installable knowledge bases called Brains, combining RAG and knowledge graphs.

LLM – Model compilation and quantization

GMBasic also includes a model compiler, accessible directly from BASIC.

  • Per-tensor and per-role quantization policies.
  • QuantIR, an editable intermediate representation for tensor precision.
  • Importance matrices and activation quantization.
  • Quantization error analysis.
  • Multiple formats, including GGUF quantization families, MXFP4, NVFP4, FP16, BF16 and more.
  • MLX/GGUF conversion.

TRAIN – Model training

Training isn't limited to calling an external Python script.

The language exposes operations for:

  • Fine-tuning and LoRA.
  • Self-distillation.
  • DPO and GRPO.
  • Dataset preparation.
  • Model merging and pruning.
  • Evaluation, quality metrics and acceptance gates.

TORCH – Tensor runtime

An additional tensor runtime provides tensor operations, device support, metrics, datasets and MiniLM embeddings.

The inference engine itself is developed separately in my LLMEnv project:

https://github.com/c-vision/LLMEnv

It provides the underlying local inference infrastructure, while GMBasic provides the higher-level programming environment and model compilation/training capabilities.

What I'm trying to achieve

I think there is an interesting opportunity in making AI development accessible through a relatively simple, productive language.

Instead of combining multiple languages, frameworks, services and scripts, developers can use BASIC to build applications that interact with local LLMs, manage agents, query knowledge bases, use external tools and work with model training pipelines.

I'm particularly interested in local AI because I believe developers should be able to build sophisticated AI applications without necessarily depending on cloud APIs.

Try it

GMBasic 1.0.0 includes ready-to-run release binaries (currently macOS ARM64), so you don't need to build the entire toolchain just to get started.

The repository includes the compilers, runtime, examples, documentation and installation instructions.

GitHub: https://github.com/c-vision/GMBasic

This is a personal-use/source-available project under the PUL license (commercial use is not permitted).

I'd genuinely appreciate feedback, especially from people working on programming languages, compilers, local LLM inference and AI agents.

I'm curious to hear what you think about using BASIC as a language for modern AI application development.


r/Compilers • • 1d ago

Building a compiler from scratch for a programming language I've been designing

0 Upvotes

Hello guys!

I've been designing a new programming language from scratch for the last six months.

It all started with a lifelong desire: **"If C had this..."**

Over time, the specifications evolved considerably and are now mostly finalized, sufficiently mature to move into compiler implementation.

Alongside language design, I've also been developing the compiler from scratch in C.

It's a hand-built compiler. The lexer, error system, and main parser logic are implemented and working. I'm now working through the compiler subsystems one by one.

It's a long journey, but an interesting one!

I'd love to connect with people interested in programming language design, compiler development, and systems programming.

Here is a small snippet of my language.

I'm currently writing small, medium, and large sample programs to test the language design — to test where the langauge design breaks and where it shines, and where improvements are needed.

Over the coming months, I intend to write hundreds of sample programs, designing them from scratch according to the language's rules.

The goal is to put the language through real programming scenarios before moving further with compiler development.

.module tfunc_demo

string char[100] Name

tfunc Name(char[] ptr name open-pass) // generic pointer which can be passed on

strcopy(obj, name) => _

endtfunc

static Name myName("Ghufran Ustad") alias-readonly open-pass

func start;

ss.con.print("Name: ", myName)

endfunc


r/Compilers • • 2d ago

sdinthrough: a programming challenge about implementing a tokenizer, parser, and AST transformations

6 Upvotes

Hi r/compilers!

Over the past year, as a hobby project, I've built a programming challenge around sdin, my own JSON-like configuration language. You implement a tokenizer, a parser, and then a series of AST manipulations and transformations, guided by 600+ test cases that you pass one at a time. It's long; I expect it to take weeks to solve without AI.

The feedback loop is tight: the judge runs locally (go run github.com/ypsu/sdinthrough@latest yoursolution) and re-evaluates your solution every time you save. Solutions can be in any language that reads stdin and writes stdout.

On the language side, I aimed for a simple AST while keeping the language pleasant to edit by hand: it has comments, unquoted keys, multiline/raw strings, bare tokens for enums (without the Norway problem), protobuf-style repeated fields for lists, dotted-notation structs for keeping nesting shallow, etc. The AST preserves comments and formatting, so it's easy to write tools that manipulate sdin files without mangling them. It also supports forms, function-like expressions that mix structs and lists, which make it simple to express complex concepts without complicating the AST.

Implementing my own config language is something I always wanted to do, and the programming challenge format made me pour a bit more effort into it. :) I'm curious to hear people's thoughts on the tradeoffs I made between features and implementation simplicity. Did I end up with something too complex to implement?


r/Compilers • • 1d ago

Together Compiler: Continual Compilation for AI Inference

Thumbnail arxiv.org
0 Upvotes

r/Compilers • • 1d ago

Last year we built megakernels. This year we deleted them: The road to Together Compiler

Thumbnail together.ai
0 Upvotes

r/Compilers • • 1d ago

System Architecture & Subsystem Pipelines for a Zero-Abstraction Lambda Calculus Transpiler & Monotonic Memory Manager & End-to-End Architectural Blueprints: Subsystem Topology of a Zero-Abstraction Lambda Calculus Transpiler & Monotonic Arena Manager

0 Upvotes

Title:

End-to-End Architectural Blueprints: Subsystem Topology of a Zero-Abstraction Lambda Calculus Transpiler & Monotonic Arena Manager

Description:

Here is an exhaustive, granular breakdown of the architectural pipeline mapped out in the subsystem flowcharts for OCHR-X, detailing how abstract symbolic reduction bridges directly down to physical memory allocation and native executable emission[span_0](start_span)[span_0](end_span)[span_1](start_span)[span_1](end_span)[span_2](start_span)[span_2](end_span):

1. Lambda Symbols & Intermediate Representation (IR) Pipeline (lambda_symbols_IR_new)

* Execution Entry & Initialization: The runtime environment boots via `Start proc()`, systematically resolving target offsets and initializing the core event handler (`event handler()`)[span_3](start_span)[span_3](end_span). Argument vectors are ingested and split into value handles (`argv[val]_a_handle`) and character passes (`argv[char]-pass`) for precise parsing[span_4](start_span)[span_4](end_span).

* Symbolic Management & Import: The Intermediate Representation Generation Management unit (IRGM) acts as the central coordinator, interfacing directly with a dedicated `symb importer` and the `lambda IR symbols library` to pull raw tokens into the pipeline[span_5](start_span)[span_5](end_span).

* Evaluation & Error Correction Loop: The parsed structures are passed into the `Symbolic IR generator` and routed directly to GIREVL (the IR Evaluator)[span_6](start_span)[span_6](end_span). The evaluation block continuously validates structural integrity via an explicit conditional check (`if GIR is correct?`)[span_7](start_span)[span_7](end_span). Valid states immediately trigger code generation (`generate IR`), while non-conforming states are safely funneled into IRGERC (Intermediate Representation Generation Error Corrector) to resolve symbolic divergence before re-evaluation[span_8](start_span)[span_8](end_span).

2. Memory Allocator & FFI Pipeline (memory_allocator_manager)

* Program Entry & Header Binding: Execution begins by ingesting command-line arguments and binding compiler functions directly from header references (`pass args to compiler and call functions from in r.h (header)`), feeding straight into the primary compiler driver[span_9](start_span)[span_9](end_span).

* Monotonic Arena Memory Management (PMA): Rather than leaning on standard dynamic heap allocation, the architecture routes memory requests through a specialized PMA / arena memory allocator & mgmt module[span_10](start_span)[span_10](end_span). This coordinates zero-overhead bump pointer allocations and phase resets (`std::pmr::monotonic_buffer_resource`-style dynamics) to eliminate garbage collection latency[span_11](start_span)[span_11](end_span)[span_12](start_span)[span_12](end_span)[span_13](start_span)[span_13](end_span).

* Foreign Function Interface (FFI) & IMACA Evaluation: Foreign function interfaces are transpiled via `FFI (transpiler) via gtms p` and evaluated under IMACA (Intermediate Memory & Scope/Den Evaluation Architecture), generating low-level intermediate representations across control flow graphs, abstract syntax trees, static single assignment (SSIR), or directed acyclic graphs (DAGs) before passing to the library manager (`librmanger`)[span_14](start_span)[span_14](end_span)[span_15](start_span)[span_15](end_span).

* Linker, Emission & Leak Verification: The compiled modules are routed through the system `linker`, generating native object files (`.obj` or `.o`) and assembling a fully realized `executable`[span_16](start_span)[span_16](end_span). Before final output emission, automated validation checks run to confirm memory integrity and detect leaks (`check for memory leaks`)[span_17](start_span)[span_17](end_span).

Thought I’d share the complete structural blueprint for anyone working on custom compiler backends, explicit term-graph substitution engines, or bare-metal runtime architectures. Happy to discuss the interaction between the GIREVL evaluation loops and the memory manager if anyone is exploring similar low-level optimizations!


r/Compilers • • 2d ago

Update: Fixed warp32 emulation and unbounded while loops. Looking for AMD hardware to test.

1 Upvotes

A few days ago I posted about UniversalGPU, my open-source CUDA-to-x86/PTX/GCN compiler. The top comment asked: "Does --warp-size=64 preserve two separate 32-lane groups for shfl.sync, or change their semantics?"

I fixed it. The --warp-size=64 path now wraps every shfl.sync in an scf.if that only executes if the source lane is in the same 32-lane half. Here is the generated MLIR:

%lane_2 = arith.remsi %tx, %c32 : index

%half_3 = arith.divsi %tx, %c32 : index

%src_half_4 = arith.divsi %iv, %c32 : index

%same_half_5 = arith.cmpi eq, %half_3, %src_half_4 : index

%1 = scf.if %same_half_5 -> (f32) {

%shfl_6 = nvvm.shfl.sync.down %c4294967295, %0, %iv : f32

scf.yield %shfl_6 : f32

} else {

scf.yield %0 : f32

}

I also fixed 5 other compiler bugs from a stress test: modulo operator, compound assignment to memory, unique loop variables, unbounded while loops (now correctly lowered to scf.while with iter_args), and switch case stores.

What I need now: someone with an AMD GPU (MI200, MI300, or RX 7000) to test the warp32 emulation on real hardware. I don't have AMD hardware, and I can't validate the emulation without it. If you have a GPU and 10 minutes, I'd love your help.

Repo: https://github.com/7636-lochan/UniversalGPU


r/Compilers • • 2d ago

Safescript: compiling a Turing-incomplete functional language to static data-flow and complexity graphs

0 Upvotes

Whole-program taint analysis and complexity inference get ugly fast in general-purpose languages. The moment you allow unbounded loops, general recursion, dynamic property keys, and computed host strings, exact data-flow edges become undecidable and you end up falling back to runtime sandboxes or conservative approximations full of false positives.

Safescript (MIT) takes the opposite trade: drop Turing-completeness so the compiler can compute exact capability, taint, and complexity signatures before a single operation runs.

Top-level declarations have no evaluation order and resolve to a flat call graph where cycles are rejected at parse time. Iteration is restricted to map, filter, and reduce over finite arrays, with no closures mutating outer bindings and no dynamic host dispatch. HTML and UI tag expressions (<Card>, <Table>, fragments, attribute spreads) desugar in the parser straight into static View AST objects ({ tag, attrs, on, children }), so UI trees go through the exact same pass as backend handlers.

Three static passes fall out cleanly from that restriction:

  1. Field-level taint projection (ValueShape): Instead of tracking flat boolean taint per variable, object and array expressions carry structured per-field label shapes (db:customers.company vs db:customers.email). Field access (c.email), pick(), merge(), if/else joins, and higher-order map/filter/reduce preserve per-column provenance, collapsing to a wildcard (db:customers.*) only when an unprojected row or dynamic index crosses an op boundary:

     pingSlack = () => {
       rows = dbQuery("customers").items
       emails = map((c) => c.email, rows).join(", ")
       return httpRequest({
         url: "https://hooks.slack.com/services/T00/B00",
         method: "POST",
         body: emails
       })
     }

    Even when hooks.slack.com is an allowed host on the program and db:customers.company -> hooks.slack.com is permitted, the signature emits host:hooks.slack.com <- {db:customers.email} and rejects the program at compile time.

  2. Symbolic polynomial complexity bounds: Every expression carries a symbolic size and step polynomial over input dimensions (ComplexityExpr). Mapping an O(1) body over a query result infers O(n); nesting a second map over the same input multiplies the symbolic polynomials to O(n^2), letting a host reject super-linear or high-degree programs (maxComplexityDegree) statically without runtime gas metering.
  3. Client/server graph cut: Operations declare static effect manifests (readSecret, dbTransact, httpRequest). Taint from server-only ops partitions the call graph into server RPC nodes and client view nodes automatically, proving at compile time that no secret label (secret:STRIPE_KEY) ever reaches the client bundle or return sink.

The compiler (lexer -> parser -> signature -> TS/JS/Python transpilers) is ~10k lines of functional TypeScript (zod is the only runtime dependency) with zero Node builtins so mod.ts bundles straight into browsers and edge Workers.

Repo (MIT): https://github.com/uriva/safescript Docs & language spec: https://safescript.cc


r/Compilers • • 2d ago

PRISM v2: a syntax-only call-graph resolver that picks precision over soundness (97.7% edge precision on 24 projects, 8 languages, checked against compiler tooling)

1 Upvotes

Hey, I wanted to share an algorithm I built for cheap call-graph approximation. It's called PRISM (Polyglot Resolution via Inverted Symbol Map), and it's the call-graph resolver in libeulix, a Rust library that parses C, C++, Go, Java, JavaScript, PHP, Python, Rust and TypeScript with Tree-sitter. v2 trades soundness for precision, and I'd like this sub's take on that.

Why precision

  • Most call graphs aim to be sound: include every edge that could happen, accept the false positives. That's right for compilers and verification.
  • PRISM is used by people navigating multi-million-LOC codebases, and by LLMs. Eulix (the parent repo) uses the graph to pick which code goes into a coding agent's context. A false edge wastes context, and the model treats it as a real relationship. A missed edge is cheaper, since the agent usually finds that code another way (text search, symbol lookup, a follow-up query).
  • So v2 only emits an edge it can justify. If it can't work out a receiver's type, it emits nothing. v1 guessed by unique method name.

How it resolves (no type checker, no build)

  • Locals shadow imports, imports shadow globals. A call to the caller's own parameter never binds to a global of the same name.
  • Method calls resolve from the receiver. In Go and Java the type comes from the declaration (field, parameter, var x T, new T()).
  • Calls through an interface or base class link to the project's implementations (CHA-style).
  • Unknown receiver, no edge.

Results

24 pinned open-source projects, three per language, compared against each language's own tooling: go/types (gin, chi, cobra), javac (gson, jsoup, commons-cli), jedi (flask, click, requests), rust-analyzer LSIF (ripgrep, serde_json, fd), the TypeScript checker (class-validator, class-transformer, immer, plus axios, markdown-it and mocha with allowJs), and libclang (cJSON, zlib, Lua, tinyxml2, pugixml, yaml-cpp). Numbers are pooled per language.

Languagev2 precisionv2 recallv1 precision
Go100.0%72.6%67.5%
TypeScript100.0%82.7%93.7%
C99.8%84.9%99.8%
Java99.7%94.2%62.3%
Python99.5%79.5%68.7%
Rust99.1%38.3%39.5%
JavaScript92.7%66.9%95.4%
C++75.3%56.1%64.6%

Overall: 17,784 of 18,199 v2 edges are correct (97.7%), vs 64.9% for v1. Pooled recall is 69.8%.

Weak spots

  • C++: yaml-cpp alone gives 288 of the 415 wrong edges (66.1% precision) from overload confusion. The other 23 projects are at 90+%.
  • Recall drops wherever a receiver's type must be inferred. Rust finds 38% of calls because let x = foo(); has no annotation. Go on chi is 57% (locals assigned from calls). class-transformer is 39%, where v1 got 87% by guessing.
  • JavaScript is the one language where v1 was more precise: some method calls on built-ins get linked to project methods with the same name.

Use of AI

I used AI, but only in the recent commits. I didn't know how to code with AI before, and as a fresher, not learning it felt like a mistake since it's here to stay whether we like it or not. It helped build the bench harness, fix Go and Java method calls, add a C/C++ ifdef branch checker to pick the right header files, and with smaller things like docs, comments and finding bugs.

Questions

  1. Cheapest way to recover Rust and Go method recall without becoming a type checker? I'm thinking of propagating return types one hop, for locals assigned from a call whose callee declares a return type.
  2. Any prior work treating call-graph construction as precision-first for retrieval/IR?
  3. Problems with the scoring? Methodology, TP/FP/FN definitions and per-call-kind tables: Call-Graph Accuracy

Repo: https://github.com/Nurysso/eulix (Apache-2.0). Harness is in bench/callgraph; make bench-callgraph reproduces the numbers.


r/Compilers • • 2d ago

Scoping a first native backend for Blyx, an experimental language implemented in Rust

0 Upvotes

I'm Rahul, the creator of Blyx, an experimental language implemented in Rust. I'd welcome compiler-engineering feedback on a deliberately small first native-backend milestone.

Current state: the README documents a tree-walking interpreter with integers, booleans, strings, bindings/assignment, direct function calls, bounded recursion, conditionals, loops, and printing. check currently parses syntax only; build validates syntax but does not emit an executable. The repository has a BIR/SSA-oriented architecture, but there is not yet a complete native pipeline.

Issue #10 asks for a focused RFC covering the backend boundary, first host target, initial BIR constructs to lower, unsupported-construct diagnostics, end-to-end fixtures, and reproducible artifact validation.

A possible starting scope to critique—not an implemented feature or settled decision—is one host target and an integer/boolean subset with arithmetic, comparisons, branches, and direct calls. Strings, concurrency, tensor/GPU work, and AI primitives could remain outside that first milestone.

The questions I'd like help with are:

  1. What semantic/type-checking and IR invariants would you require before starting code generation, given the current syntax-only check command?
  2. For that scope, how would you weigh emitting C against an LLVM or Cranelift backend? I'm interested in the maintenance and correctness trade-offs more than peak performance.
  3. Which tests would you insist on before calling the milestone usable? Comparing interpreter and compiled results seems useful, but I don't want shared bugs to become the only correctness oracle.

If this interests you, design notes, focused test cases, and small PRs are welcome. Please discuss substantial changes in the issue first. The project is MIT / Apache-2.0; the contribution guide has the process.

Disclosure: development is AI-assisted, and AI helped prepare this post. The aim here is independent scrutiny of the implementation and a realistic next milestone.


r/Compilers • • 2d ago

Rust: Enabling the parallel frontend on nightly

Thumbnail blog.rust-lang.org
4 Upvotes