Hasty Briefsbeta

All tags

#compiler

132 stories total

Bilingual

Fil-C: A memory-safe C implementation
6 months ago
- Fil-C is a memory-safe implementation of C and C++ that allows existing C code to run safely without modification.
- It is fanatically compatible with existing C code, making it suitable for retrofitting memory safety into legacy applications.
- Fil-C can compile an entire memory-safe Linux user space, though some complex programs require modifications.
- The project is a fork of Clang, licensed under Apache v2.0 with LLVM exceptions, and is currently based on Clang version 20.1.8.
- Performance has improved from initial slow speeds to being only a few times slower than Clang, depending on the program structure.
- Fil-C uses a different internal ABI than Clang, requiring all code to be recompiled with Fil-C for compatibility.
- The InvisiCaps pointer representation ensures memory safety while maintaining the appearance of natural pointer sizes for the architecture.
- Memory management includes a concurrent garbage collector that is both parallel and precise, using auxiliary capability information.
- Fil-C has been used to create a memory-safe Linux user space based on Linux From Scratch, though some components still require a non-Fil-C compiler.
- Despite its immaturity, Fil-C offers a compelling solution for memory safety in C programs, especially where performance trade-offs are acceptable.
Fil-C: A memory-safe C implementation
6 months ago
- Fil-C is a memory-safe implementation of C and C++ that allows existing C code to run safely without modification.
- It is fanatically compatible with existing C code, making it suitable for retrofitting memory safety into applications.
- Fil-C can compile an entire memory-safe Linux user space, with some modifications needed for complex programs.
- The project is a fork of Clang, licensed under Apache v2.0 with LLVM exceptions, and is based on Clang version 20.1.8.
- Fil-C uses 'InvisiCaps' for pointer handling, separating pointers into a trusted 'capability' piece and an untrusted 'address' piece.
- It features a concurrent and parallel garbage collector, with minimal pauses for threads during collection.
- Fil-C has been used to create a memory-safe version of Linux From Scratch (LFS), though some components still require a non-Fil-C compiler.
- Performance overhead is notable but manageable, with some programs running only a few times slower than with Clang.
- Fil-C does not support inter-language linking, such as with Rust, and requires all code to be recompiled with Fil-C.
- The project is still relatively immature, with a single active contributor, but shows promise for making C programs memory-safe.
New graph layout algorithm for SpiderMonkey's SSA compiler
6 months ago
- SpiderMonkey's optimizing compiler, Ion, now features interactive graphs for visualizing JavaScript and WebAssembly compilation.
- Users can write JavaScript code in a test function to generate and interact with these graphs, including navigation, zooming, and scrubbing through the optimization process.
- The new layout algorithm is simple, fast, and produces high-quality output, tailored specifically for SpiderMonkey's needs, implemented in less than a thousand lines of code.
- Traditional tools like Graphviz produce unstable and counterintuitive layouts, making it difficult to follow the structure of the source code.
- The new algorithm avoids complex optimizations, focusing instead on stability and readability, with specific steps like layering, creating dummy nodes, straightening edges, and tracking horizontal edges.
- The resulting graphs are more efficient and easier to navigate, even for complex functions, with rendering inspired by railroad diagrams for clarity.
- Future work includes integrating iongraph more deeply into Firefox and adding features like search and register allocation visualization, though there's no fixed roadmap.
- The source code for iongraph is available on GitHub, and contributions are welcome.
Roadmap for Improving the Type Checker
6 months ago
- Roadmap focuses on improving the Swift compiler's type checker, particularly expression type checking.
- Constraint solving in Swift involves type variables and constraints, including disjunction constraints for overload resolution.
- Swift imposes limits on type checking to prevent excessive time or memory usage, with counters for disjunction attempts and arena size.
- Recent improvements in Swift 6.2 and 6.3 include optimized disjunction selection and reduced constraint solver arena usage.
- Future improvements aim to optimize bindings, remove performance hacks, and enhance salvage mode for better diagnostics.
- Long-term goals include changes to operator lookup and polymorphic literals, and adopting advanced constraint solving techniques like those used in SAT solvers.
Wastrel, a Profligate Implementation of WebAssembly
6 months ago
- Wastrel is a new WebAssembly (Wasm) implementation that compiles Wasm modules to standalone binaries by emitting C and then compiling that C.
- Key differences from similar projects (wasm2c, w2c2) include aiming to support automatic memory management via WasmGC using the Whippet garbage collection library.
- Wastrel's CLI resembles wasmtime, compiling and running the C output by default, unlike wasm2c which focuses on C production.
- Implements WASI 0.1 (WASI preview 1), allowing direct execution of binaries using WASI imports.
- Emits optimized C code with a lightweight effects analysis to minimize useless temporaries.
- Performance benchmarks show Wastrel is 2-5% slower than native, comparable to w2c2, and significantly faster than Wasmtime.
- Implementing WASI was challenging due to the need to handle ABIs with limited types, the complexity of WASI functions like poll_oneoff, and underspecification issues.
- Uses Linux's filesystem namespaces for secure sandboxing, making it Linux-only and emphasizing a capabilities-based approach.
- Motivations include advocating for garbage collection in WASI, supporting WasmGC languages outside browsers, and promoting the Whippet GC library.
- Future goals include exploring performance against ocamlopt and enabling native compilation of Guile programs via Hoot, Whippet, and Wastrel.
Pain Points of OCaml
6 months ago
- The author is seeking a job for new graduates in 2026, with skills in Rust, TypeScript, or React.
- OCaml's syntax is criticized for being unclear, especially with nested match statements and lack of punctuation.
- Automatic currying and partial function application in OCaml often lead to bugs and inscrutable error messages.
- OCaml's type inference is powerful but can produce opaque errors, making debugging difficult.
- Types in OCaml cannot be used before declaration, and enumerated types are not namespaced, leading to potential shadowing.
- OCaml's tooling has improved, with Dune as a build system, but the ecosystem is dominated by Jane Street's Core library.
- Compiler tools like ocamllex and Menhir have their own DSLs and emit unhelpful 'Syntax Error' messages.
- Printing in OCaml is cumbersome, requiring custom print functions for objects, unlike Rust's #[derive(Debug)].
- Rust is praised for robustness and maintainability, while OCaml is seen as elegant but less practical for long-term projects.
- Despite its flaws, OCaml is considered for future compiler projects due to its functional approach and pattern matching.
SPy: An interpreter and compiler for a fast statically typed variant of Python
6 months ago
- SPy is an interpreter and compiler for a statically typed variant of Python, focusing on performance.
- SPy does not aim for 100% compatibility with Python, distinguishing itself with *.spy files.
- The project integrates tightly with the Python ecosystem, allowing imports between Python and SPy.
- SPy addresses Python's performance issues by removing dynamic features that hinder optimization.
- It introduces static typing enforced at runtime, improving type safety and performance.
- SPy's design includes features like zero-cost abstractions and opt-in dynamism for flexibility.
- The language supports metaprogramming and predictable performance without 'magical optimizers'.
- SPy's development is inspired by RPython, aiming to be 'RPython 2.0' with better ergonomics.
- The project is open-source, with early development stages focusing on core features and performance.
A Note on Fil-C
6 months ago
- Fil-C is a project by Filip Pizlo that adds memory-safety instrumentation to clang, including spatial safety (out-of-bounds accesses) and a concurrent GC for temporal safety (use after free).
- It is highly compatible with existing code, potentially enabling a full Linux distro userspace with modest patching effort.
- Performance overheads are estimated at 1-4x cycles, deemed tolerable for many workloads, especially IO-bound ones.
- Fil-C builds on academic and industrial work, including Pizlo's iterations at Apple, some of which are already in production.
- The tool's bounds checking can make pointer-twiddling C code safer than unsafe Rust, raising questions about integrating similar checks into Rust's unsafe blocks.
- Caveats include dynamic (not static) error prevention, performance and space overheads, no solution for data races, and the temptation to disable safety for performance gains.
- The project reflects a shift in developer priorities towards safety, even at the cost of performance, contrasting with the historical preference for C/C++'s speed and memory efficiency.
- The author expresses hope that Fil-C will meet the needs of those with legacy C/C++ codebases or those averse to safer programming languages.
Writing a C Compiler, in Zig
6 months ago
- Series of articles written while creating paella, inspired by Nora Sandler's 'Writing a C Compiler'.
- Purpose was to learn Zig and procrastinate job searching during unemployment.
- No major edits made, only broken links fixed.
- Chapters cover various programming concepts from Unary to Linking.
- Future writeups may be added if the book project continues.
Nimony v0.2 – early preview of Nim 3.0's compiler
6 months ago
- Nimony v0.2 is an early preview compiler for a Nim variant aimed at becoming Nim 3.0.
- Focuses on Aufbruch mode: destructor-based memory management (ARC), value-centric semantics, predictable code generation, and plugin-based metaprogramming.
- Supports basic programs with a working core, targeting developers interested in testing fundamentals.
- Example program: a Tic-Tac-Toe game with AI in 250 lines using raylib for graphics.
- Several standard library modules ported, providing a well-rounded set of functionality.
- Many language features work, including methods and dynamic polymorphism, with quick bug fixes.
- Common issue: type resolution errors, though not blocking program development.
- Missing case-insensitive identifiers, noted due to odd AST node kind capitalization.
- AI chatbots (e.g., GPT5-high) used to understand current capabilities and guide testing.
- Templates and complex constants may not work, but plugins offer a solid alternative.
- Encourages community involvement: testing, bug reports, questions, PRs, and contributions via Open Collective.
Show HN: What if MCP agents were JIT compiled to code?
6 months ago
- A1 is a new agent framework that compiles agents into tools either ahead-of-time (AOT) or just-in-time (JIT).
- It serves as a replacement for frameworks like Langchain, offering improvements in safety, speed, determinism, and flexibility.
- Key features include minimizing sensitive data exposure, faster code generation, and reducing non-deterministic behavior.
- Supports tools from OpenAPI, MCP servers, databases, fsspec paths, and Python functions.
- Aims for 'determinism-maxing' by maximizing deterministic code and minimizing LLM calls.
- Includes observability via OpenTelemetry, RAG support for SQL databases, and context engineering for multi-agent behavior.
- Allows zero lock-in with any LLM or secure code execution cloud.
- Ideal for latency-critical tasks, untrusted data, or tasks needing code execution.
- Documentation and examples available in the tests/ directory and upcoming docs.a1project.org.
Switching to Rust's own mangling scheme on nightly
5 months ago
- Rust's compiler will switch to its own 'v0' symbol mangling scheme by default starting from nightly-2025-11-21.
- The previous default used C++'s mangling scheme, which had several drawbacks including loss of generic parameter information and platform incompatibility.
- The new 'v0' mangling scheme provides unambiguous encoding, reversible generic parameter information, and better compatibility with tools.
- Benefits include improved readability in backtraces, especially for async code, closures, and generic functions.
- Possible drawbacks include slightly larger symbol sizes, potentially increasing linking times and binary sizes.
- The legacy mangling scheme can still be used with the `-Csymbol-mangling-version=legacy -Zunstable-options` flag if needed.
- Tools interacting with Rust symbols can integrate the v0 demangler from the rust-lang/rustc-demangle repository.
WebAssembly from the Ground Up
6 months ago
- WebAssembly is explored through a hands-on approach, focusing on its instruction set and module format.
- The book guides readers in building a compiler for a simple programming language (Wafer) that targets WebAssembly, using JavaScript and Ohm for parsing.
- No prior compiler expertise is needed; the book provides all necessary code step by step.
- Includes 15 chapters of technical content plus two bonus chapters, with full MIT-licensed source code available for each milestone.
- Targeted at experienced programmers with intermediate JavaScript knowledge, but no prior compiler experience is required.
- The book aims to demystify compiler writing and WebAssembly, making complex topics accessible.
- Endorsements highlight the book's practical approach to understanding WebAssembly's binary representation.
GCC Steering Committee Allows New Language Front-End to Land for GCC 16
5 months ago
- GCC Steering Committee approves Algol 68 front-end for GCC 16.
- Algol 68 is an experimental addition, joining other languages like C/C++, Rust, and COBOL.
- The front-end was initially rejected in March but now allowed with specific conditions.
- Conditions include: not built by default, not part of release criteria, and maintenance requirements.
- Jose E. Marchesi appointed as the maintainer for the Algol 68 front-end.
- Algol 68 is a 50-year-old imperative language, successor to Algol 60.
- GCC 16.1 stable release expected in March-April 2024.
AI has a deep understanding of how this code works
5 months ago
- DWARF v5 debug information support added to OCaml native compiler for source-level debugging in GDB and LLDB.
- Core DWARF support includes function, type, and line number debug info following DWARF 4/5 specifications.
- Platform support covers macOS (Mach-O) and Linux (ELF) with architecture-specific implementations for AMD64 and ARM64.
- Tooling includes LLDB Python extensions for OCaml value pretty-printing and enhanced debugging commands.
- Command-line interface adds -g flag for DWARF generation and options for controlling debug info detail.
- Implementation includes variable tracking through compilation pipeline and proper scope handling for let-bound variables.
- Comprehensive testing verifies debugger functionality including breakpoints, source locations, and variable inspection.
- PR includes 13k lines of code but faced integration challenges due to AI-assisted development approach.
- Discussion highlights tensions between AI-generated contributions and traditional open-source collaboration practices.
JOPA: Java compiler in C++, Jikes modernized to Java 6 with Claude
5 months ago
- A fork of Jikes, the historical independent javac implementation in C++, modernized with comprehensive Java 5 and Java 6 language features.
- Key Java 5/6 features added: Generics, Enhanced For-Loop, Varargs, Enums, Autoboxing/Unboxing, Static Imports, Annotations, Class file version 50.0, and Debug information.
- Requirements include CMake 3.20+, a C++17 compiler, and optional iconv/ICU for encoding support.
- Build instructions provided for both Nix and generic CMake setups, including useful CMake options.
- Jikes was originally developed by Philippe Charles and Dave Shields at IBM Research, first released in 1997.
- Notable for its speed (10-20x faster than javac), error correction, and quality of error messages.
- IBM's first open-source project, included in Red Hat Linux in 1999, with IBM ending involvement in late 1999.
- Active development ceased in 2005 due to changes in Java language, particularly generics.
- Still useful for beginners or as a study subject for compiler courses.
- Notable features: written from scratch in C++, efficient storage allocator, no third-party parser tools except Jikes Parser Generator.
- Repository includes versions 1.04 through 1.22, sourced from Sourceforge in 2012.
- Original authors and numerous contributors listed, highlighting the project's collaborative nature.
Inside VOLT: Designing an Open-Source GPU Compiler
5 months ago
- VOLT (Vortex-Optimized Lightweight Toolchain) is an open-source GPU compiler designed to support SIMT execution on emerging open GPU architectures.
- The compiler framework is technically complex and often underestimated in open hardware development costs.
- VOLT enables SIMT code generation and optimization across multiple levels of abstraction through a hierarchical design.
- It centralizes fundamental SIMT-related analyses and optimizations in the middle-end for reusability and adaptability to new GPU variants.
- Two case studies demonstrate VOLT's support for ISA extensions and host-runtime API extensions.
Xbasic: 1980s era BASIC, compiler to x86-64, complete with test suite
5 months ago
- xbasic64 compiles 1980s-era BASIC dialects (Tandy Color BASIC, GW-BASIC, QuickBASIC) directly to native x86-64 executables.
- Supports classic BASIC syntax with line numbers or structured code.
- Includes numeric types (Integer, Long, Single, Double) and string handling functions (LEFT$, MID$, etc.).
- Features control flow structures like IF/THEN/ELSE, FOR/NEXT, WHILE/WEND, DO/LOOP, and SELECT CASE.
- Supports procedures (SUB and FUNCTION) with recursion and file I/O operations.
- Compiles using a three-stage pipeline: Source → Lexer → Parser → Code Generator → Assembly → Executable.
- Uses a runtime library for I/O, string operations, and math functions in x86-64 assembly.
- Key design choices include no intermediate representation (IR), System V AMD64 ABI, and GW-BASIC type semantics.
- Requires Rust toolchain, system assembler (as), and system C compiler/linker (cc) with libc.
- Compatible with macOS (x86-64, ARM64 via Rosetta) and Linux (x86-64).
Baboon: Data Modeling with Automatic Evolutions and tagless binary codecs
5 months ago
- Baboon is a minimal Data Modeling Language and compiler with ergonomic, declarative schemas.
- Features set-based structural inheritance with +, -, and ^ operators.
- Automatic codec derivation for JSON and UEBA (Ultra-Efficient Binary Aggregate).
- Evolution-aware codegen with migrations and stubs for manual work.
- Supports structural and nominal inheritance, namespaces, includes, and imports.
- Collections include opt, lst, set, map, and timestamps/UID primitives.
- Codegen targets: C#, Scala, with plans for more.
- Deduplicated C# output for lower binary footprint.
- Intellij Idea Plugin and VSCode/VSCodium Extensions available.
- Limitations include no templates, limited nominal inheritance, and no newtypes/type aliases.
- Points marked with (*) may be improved in the future.
- Types not referenced by root types are eliminated from compiler output.
- Foreign types require custom codecs and careful handling.
- Project uses mudyla for build orchestration with various build and test commands.
GCC 16 Switches to Using C++20 Standard by Default
5 months ago
- GCC 16 will use C++20 as the default standard instead of C++17.
- GCC developers fixed C++20 compatibility issues in their codebase.
- The change to C++20 default was approved during stage 3 development for GCC 16.1 stable release.
- Build issues may arise for projects not ready for C++20 unless they specify "-std=c++17".
- Open-source projects testing against GCC Git have a few months to adapt to C++20.
- GCC 11 switched the default from C++14 to C++17 in 2020.

first prev4next

About|Login

#compiler

Fil-C: A memory-safe C implementation

Fil-C: A memory-safe C implementation

New graph layout algorithm for SpiderMonkey's SSA compiler

Roadmap for Improving the Type Checker

Wastrel, a Profligate Implementation of WebAssembly

Pain Points of OCaml

SPy: An interpreter and compiler for a fast statically typed variant of Python

A Note on Fil-C

Writing a C Compiler, in Zig

Nimony v0.2 – early preview of Nim 3.0's compiler

Show HN: What if MCP agents were JIT compiled to code?

Switching to Rust's own mangling scheme on nightly

WebAssembly from the Ground Up

GCC Steering Committee Allows New Language Front-End to Land for GCC 16

AI has a deep understanding of how this code works

JOPA: Java compiler in C++, Jikes modernized to Java 6 with Claude

Inside VOLT: Designing an Open-Source GPU Compiler

Xbasic: 1980s era BASIC, compiler to x86-64, complete with test suite

Baboon: Data Modeling with Automatic Evolutions and tagless binary codecs

GCC 16 Switches to Using C++20 Standard by Default