Hasty Briefsbeta

All tags

#compiler

132 stories total

Bilingual

Show HN: The C3 programming language (C alternative language)
a year ago
- C3 is an evolution of the C language, maintaining familiarity for C programmers.
- Precompiled binaries available for Windows, Debian, Ubuntu, and MacOS.
- Full ABI compatibility with C allows mixing C and C3 in projects.
- Key features include procedural design, C ABI compatibility, and easy transition for C programmers.
- Avoids 'big ideas' and focuses on necessary changes with some higher-level conveniences.
- Inspiration from C2 language, aiming to iterate on C without being a completely new language.
- Example features: generic modules, no mandatory header files, new semantic macro system.
- Current stable version is 0.7.0, with future updates focusing on standard library expansion and bug fixes.
- Compiler verified on Linux, Windows, and MacOS with detailed support matrix provided.
- Community contributions encouraged via issues, Discord, and specific project needs like library bindings.
- Installation instructions provided for various platforms including Windows, Linux, and MacOS.
- Building from source requires CMake, LLVM, and other dependencies with platform-specific steps.
- License: C3 compiler under LGPL 3.0, standard library under MIT.
- Editor plugins available for integration with development environments.
- Testing guidelines and contribution acknowledgments included.
Make C string literals const?
a year ago
- Martin Uecker proposes changing the type of string literals to a const-qualified base type in C, similar to C++.
- Compilers already support this, either by default or via command-line switches.
- This change would be normative and might impact existing code, so feedback is sought.
- Feedback requested includes experiences with projects already using const-qualified string literals, ease of adoption, or potential difficulties.
- The goal is to gather facts, not opinions, with specific requests for project details and experiences.
- Open-source projects should provide pointers; commercial projects should describe without sharing confidential information.
- Reports should focus on actual experiences with const qualification options, not speculation.
Apple M1 / M2 / M3 Core Support Might Soon Be Merged for the GCC Compiler
a year ago
- Apple M1/M2/M3 core support may soon be merged into the GCC compiler.
- GCC developer Iain Sandoe, with input from Arm and Apple engineers, is working on this support.
- A new patch for GCC on AArch64 Darwin (macOS) adds targets for apple-m1, apple-m2, apple-m3, and apple-a12.
- The patch could be merged in GCC 15.1 or deferred to GCC 16, providing optimized Apple Silicon support as an alternative to LLVM.
Vishap Oberon Compiler
a year ago
- Vishap Oberon is a free and open-source (GPLv3) implementation of the Oberon-2 language and libraries.
- It supports multiple platforms including Linux, BSD, Android, Mac, and Windows.
- The compiler (voc) uses a C backend (gcc, clang, tcc, or msc) to compile Oberon programs.
- Includes libraries from Ulm, oo2c, and Ofront Oberon compilers, complying with Oakwood Guidelines.
- Easy installation steps: install prerequisites, clone repository, run 'make full', optionally install system-wide, and set PATH.
- Supports writing 'Hello' programs in Oberon with examples provided.
- License details: GPLv3 for most components, with some libraries under GPL.
- Platform support includes 32 and 64-bit architectures, with recognition for Linux, BSD, Cygwin, and Windows.
- Language support includes Oberon-2 features and some Oberon-07 features.
- History traces back to Joseph Templ's Ofront, with contributions from Norayr Chilingarian and David Brown.
- The name 'Vishap Oberon' is inspired by Armenian dragons, symbolizing the project's uniqueness and ties to Oberon's legacy.
Usability Improvements in GCC 15
a year ago
- GCC 15 introduces prettier execution paths with emojis and ASCII art for better visualization of static analyzer warnings.
- A new look for C++ template errors with nested bullet points and clearer structure to improve readability.
- Machine-readable diagnostics with SARIF format support, capturing detailed information like command-line arguments and timestamps.
- Easier transition to C23 with improved error messages for compatibility issues.
- Revamped color scheme to highlight and distinguish differences in type mismatches and other diagnostics.
- New shared library libgdiagnostics providing GCC's diagnostic features for other projects via C, C++, and Python APIs.
Awe – Modern compiler for Algol W
a year ago
- ALGOL W is a successor to Algol 60, based on work by Niklaus Wirth and C. A. R. Hoare.
- Features of ALGOL W include dynamically allocated records, string handling, complex numbers, and a standard I/O system.
- Awe is a new compiler for ALGOL W, implementing the language as described in the ALGOL W Language Description (June 1972).
- Awe is compatible with code for the OS/360 ALGOL W compilers with minimal modifications.
- Requirements for compiling Awe include a Unix-like OS, GCC, Python3, OCaml, and Boehm GC.
- Acknowledgments to several individuals for expert advice, encouragement, and testing, and to the authors of the ALGOL W Language Description.
- A suggestion to support the developer by purchasing books by the late Frank Key.
Rust to C compiler – 95.9% test pass rate, odd platforms
a year ago
- Author will give a talk about the Rust to C compiler project during Rust Week in Utrecht, Netherlands.
- Core test pass rate has improved to 95.9%, up from 92% two months ago.
- Fixes implemented have also benefited the .NET side, with 96.3% of Rust core tests now running in .NET.
- Discovered and fixed issues with 128-bit intrinsics, checked arithmetics, and subslicing.
- Implemented emulation for 128-bit intrinsics like popcount by summing bits from lower and higher halves.
- Fully implemented checked arithmetic operations for 128-bit integers, including overflow checks.
- Fixed a subslicing bug where slice data pointer was offset incorrectly.
- Leveraged Rust compiler's built-in emulation for certain intrinsics to avoid manual implementation.
- Working on improving C compiler compatibility to support more platforms, including proprietary ones.
- Optimized generated C code by using shorter integer literal forms and smarter debug info embedding.
- Refactored rustc_codegen_clr for better incremental builds and memory efficiency.
- Progressing towards a more streamlined IR by removing complex temporary scopes.
- Planning to release part 2 of 'Rust panics under the hood' and a memory profiler for Rust.
Calypsi: A series of C compiler and assembly language cross compiler tool chains
a year ago
- Calypsi is a series of C compiler and assembly language cross compiler tool chains aimed at retro and hobby communities.
- Latest release is 5.10, supporting targets like MOS 6502, WDC 65816, Motorola 68000, and HP Nut.
- Supported host platforms include Arch Linux, Debian-based Linux, Fedora-based Linux, macOS x86, and Windows 64-bit.
- Features include ISO C 99 compiler, fully re-entrant code model, support for all integer types up to 64 bits, and floating point support.
- Includes optimizing compiler, source code debugger, and supports ELF/DWARF, hex output, and target-specific formats.
- Tools are closed source but free for hobby use; commercial use requires permission except for HP-41 Nut target.
- 6502 target supports MOS6502, WDC65C02, and 45GS02 processors with Commodore board support for Commodore 64, MEGA65, and Commander X16.
- 65816 target supports WDC65816 processor with Foenix C256 and F256 board support.
- 68000 target supports Motorola 68000, 68020, 68040, and partial Apollo 68080 core with Amiga runtime support.
- Nut target supports HP-41 Nut and NEWT processors with modules like OS4, Ladybug, and Boost41.
Ruby: Proposal to Upstream ZJIT
a year ago
- Proposal to upstream ZJIT, a next-generation Ruby JIT developed by Shopify.
- ZJIT introduces a Static Single Assignment (SSA) Intermediate Representation (IR) for better optimization and modularity.
- Aims to overcome YJIT's limitations in inlining and cross-instruction optimizations.
- Designed to be more approachable for contributors outside Shopify, fostering community involvement.
- Current status: Early development, supports x86-64 and arm64, with plans for Ruby 3.5 compatibility.
- Objectives include fast JIT-to-JIT calls, polymorphic inline caches, and dead-code elimination.
- Long-term goals include aggressive inlining, GC optimization, and allocation elision.
- Merging strategy involves keeping YJIT as default, with ZJIT opt-in via a command-line switch.
- Matz supports the upstreaming, trusting the team's approach.
- Discussion includes the benefits of a method-based JIT over LBBV for optimization and profiling.
Pydrofoil: Accelerating Sail-based instruction set simulators
a year ago
- Pydrofoil is a multi-stage compiler that generates instruction set simulators (ISSs) from processor instruction set architectures (ISAs) specified in Sail.
- It achieves a >230x speedup over the C-based ISS generated by Sail on benchmarks.
- Pydrofoil combines an ahead-of-time (AOT) compiler with a tracing just-in-time (JIT) compiler built on the PyPy framework.
- It employs domain-specific optimizations tailored for ISS workloads, which are dominated by bit manipulation operations.
- The hybrid approach of AOT and JIT compilation provides greater performance gains than using either alone.
New C++ features in GCC 15
a year ago
- GCC 15.1 is expected to be released in April or May 2025.
- GCC 15 is the system compiler in Fedora 42 and will be available in RHEL via the Red Hat GCC Toolset.
- The default dialect in GCC 15 remains -std=gnu++17, with options for C++23 and C++26 features.
- C++26 features in GCC 15 include pack indexing, attributes for structured bindings, and enhanced support for deleted functions.
- Pack indexing allows direct access to elements in a variadic template pack.
- Attributes can now be applied to structured bindings.
- Deleted functions can include a reason message with =delete("reason").
- Variadic friends allow using a friend declaration with a parameter pack.
- constexpr placement new is now supported in C++26.
- Structured bindings can now be used in conditions like if and while statements.
- Deleting a pointer to an incomplete type is now invalid in C++26.
- The Oxford variadic comma usage without a preceding comma is deprecated.
- Array comparison is now ill-formed in C++26.
- #embed directive for including binary data is introduced in C++26.
- Several defect reports have been resolved in GCC 15.
- Range-based for loops now correctly extend the lifetime of temporaries.
- Qualified lookup failures are diagnosed earlier during template parsing.
- Concepts TS support has been removed, requiring migration to C++20 Concepts.
- New compiler options like -fassume-sane-operators-new-delete and -Wheader-guard have been added.
- Improvements in compile-time speed for template-heavy code.
- New attributes like flag_enum and warnings like -Wself-move and -Wdefaulted-function-deleted have been introduced.
GCC, the GNU Compiler Collection 15.1 released
a year ago
- GCC 15.1 has been released as a major update from GCC 14.x.
- GCC now stands for GNU Compiler Collection, reflecting its support for multiple languages.
- The GCC team acknowledges contributions from volunteers worldwide.
- Users can obtain GCC via mirror sites or version control systems.
- The GCC project is maintained by the GCC team and supported by the Free Software Foundation.
ATS3 Xanadu Released
a year ago
- ATS3 is the third edition of ATS, currently under development at ATS-Xanadu.
- XATSHOME is a learning and contribution hub for ATS3.
- The 'contrib' directory includes 'contrib/githwxi' as an example for setting up personal directories.
- The ATS3-to-JS compiler is stored in 'xassets/JS/xats2js/xats2js_jsemit01_dats_opt0.js'.
- Set the environment variable XATSHOME to its directory location (e.g., '~/Research/XATSHOME').
- Compile ATS3 code to JS using 'node --stack-size=8000' with the compiler script.
- Generated JS code requires runtime files from 'xassets/JS/xats2js/runtime/' to execute.
- Refer to 'contrib/githwxi/pground/proj001@250424/misc001/Makefile' for a complete compilation example.
Co-dfns: High-performance, reliable, and parallel APL
a year ago
- Co-dfns is a high-performance, high-reliability compiler for a parallel extension of Dyalog dfns, a functional APL dialect.
- It introduces explicit task parallelism with implicit synchronization and determinism structures.
- The project aims to make scalable APL programming accessible to domain experts.
- Documentation is available in the docs/ folder, and support is offered via email ([email protected] for Co-dfns/APL, [email protected] for Dyalog APL).
- Funding is open to contributions via Patreon (https://www.patreon.com/arcfide), code, feedback, or benchmarks.
- Contributions require dual-licensing and copyright transfer; pull requests are preferred for visibility.
- Related initiatives include Mystika (cryptographic stack) and apixlib (image processing).
- Numerous publications and talks discuss Co-dfns, covering topics like APL performance, parsing, machine learning, and compiler design.
COBOL front-end added to GCC
a year ago
- GCC 15 introduces numerous improvements, including deprecated features, new compiler options, and enhanced diagnostics.
- Deprecation of -mabi=ilp32 and -fdiagnostics-format=json, with SARIF recommended for machine-readable diagnostics.
- Changes in union initialization behavior in C/C++, requiring explicit zero initialization for padding bits.
- Enhancements to -O2 optimization, including better handling of unknown trip counts but still limiting vectorization in certain cases.
- New OpenMP 6.0 features supported, including self_maps clause, unified_shared_memory, and various allocators.
- Improvements in Ada/SPARK, including new attributes like 'Round and 'Super, and aspects like Finalizable.
- New warnings and diagnostics options, such as -Wtrailing-whitespace and -Wheader-guard, added to improve code quality checks.
- Support for C23 features, including #embed directive, __STDC_VERSION__ update, and new builtins like __builtin_stdc_rotate_left.
- C++ enhancements include new library features like std::flat_map, std::flat_set, and improvements in std::format.
- Fortran updates include new intrinsic functions, unsigned modular integers, and compatibility changes in .mod file format.
- Rust support improvements in gccrs, including better error handling, support for let-else, and specialization features.
- ARM architecture updates with new CPU and architecture support, including Armv9.5-A and various new extensions.
- AVR enhancements, including new function attributes like signal(num) and interrupt(num), and support for __flashx address space.
- x86 architecture updates include new compiler switches for AMX extensions, AVX10.2 support, and deprecation of older features.
- Diagnostics improvements, including SARIF output enhancements, better source location tracking, and new libgdiagnostics library.
NVC: VHDL Compiler and Simulator
a year ago
- NVC is a VHDL compiler and simulator supporting VHDL-2008 and experimental VHDL-2019.
- It focuses on simulation performance using LLVM to compile VHDL to native machine code.
- NVC is not a synthesizer; it only implements simulation behavior per IEEE 1076 standard.
- Supports verification frameworks like OSVVM, UVVM, VUnit, and cocotb.
- Simulation involves three steps: analyzing, elaborating, and running the design.
- NVC is free software under GNU GPL v3+, with some libraries under Apache 2.0.
- Available on multiple platforms including Linux, macOS, and Windows via MSYS2.
- Installation options include package managers (brew, winget) and building from source.
- Supports various VHDL standards (1993, 2000, 2002, 2008, 2019) with --std argument.
- Includes scripts to compile popular verification frameworks and FPGA vendor libraries.
Using Coalton to Implement a Quantum Compiler
a year ago
- Quilc is an optimizing compiler for quantum computers written in Common Lisp, capable of compiling arbitrary quantum programs into code for various quantum computing architectures.
- Coalton, a strictly typed language within Common Lisp, addresses runtime type errors and lack of useful abstractions in dynamically typed languages, making it suitable for implementing new features in quilc.
- Discrete compilation is a significant new feature in quilc, implemented using Coalton, which allows quantum programs to be compiled into a set of discrete native operations, avoiding the precision issues of continuous operations.
- The Ross-Selinger algorithm is used for discrete compilation, focusing on decomposing parametric operations like RZθ into a set of discrete operations (Clifford+T set), enabling arbitrary precision approximations.
- Coalton's type classes and ad hoc polymorphism facilitate the implementation of mathematical objects and operations required for the Ross-Selinger algorithm, such as arithmetic over specific number rings.
- Quilc's discrete compilation feature is validated through numerical experiments, showing convergence to expected probabilities and efficient operation counts as precision increases.
- The implementation demonstrates Coalton's capability to handle complex mathematical algorithms efficiently and correctly, paving the way for further improvements and contributions to the language.
Scala 3.7.0 Released
a year ago
- Scala 3.7.0 introduces stabilized SIPs, including Named Tuples (SIP-58) and Binary APIs (SIP-52).
- Named Tuples allow meaningful field names in tuples and enhance pattern matching and metaprogramming.
- Binary APIs stabilize the @publicInBinary annotation for better binary compatibility in inline methods.
- Preview features, like SIP-62's improved for-comprehensions, are introduced for early adoption.
- Experimental features include @unroll for binary compatibility (SIP-61) and reference-able package objects (SIP-68).
- New given prioritization rules are now the default, improving context-bound resolution.
- The expression compiler is integrated into the main Scala 3 compiler, enhancing tooling support.
- Presentation compiler improvements include showing inferred types on hover for type holes.
- Quotes API updates allow dynamic import construction and selective implicit summoning.
- Linting improvements include better unused import detection and enhanced -Wconf filtering.
- Implicit parameter warnings now encourage using the 'using' keyword for clarity.
- Scala 3.7.0 improves Android compatibility by addressing ART runtime constraints.
- Dependent case classes are now supported, enabling more expressive type-safe configurations.
- REPL enhancements include the :jar command for adding dependencies dynamically.
- Dependency updates include Scala 2.13.16 standard library and Scala.js 1.19.0.
- Future plans include Scala 3.8 as the last minor version before the LTS release in 2026.
Beating the fastest lexer generator in Rust
a year ago
- Lexer generators aim to simplify lexer creation and improve performance over hand-written implementations.
- Performance comparisons between logos and a naive lexer implementation show logos is faster on Apple M1 but slower on x86_64.
- Speculative execution differences between architectures affect lexer performance.
- Perfect hash functions are used for efficient keyword matching, leveraging that keywords fit into a 64-bit register.
- Optimizations for ASCII text can significantly improve lexer performance, as most source code is ASCII.
- Vectorization and SIMD instructions can be used to optimize lexer performance, especially for predictable patterns like whitespace.
- Benchmarking with realistic data shows the naive implementation can outperform logos by 20-30% in some scenarios.
- Keyword frequency and identifier patterns in real-world code affect the relative performance of lexer implementations.
Loko Scheme, an optimizing, bare-metal Scheme compiler
a year ago
- Loko Scheme is an optimizing Scheme compiler available via git clone from https://scheme.fail/git/loko.git/.
- It is also available through package repositories like Guix and Docker.
- A bootable hard drive image is provided for machines with ≥1GB RAM.
- Licensed under EUPL-1.2-or-later, a copyleft license with a SaaS clause.
- Includes limited hardware support and works on real hardware, though it requires a legacy PIC.
- Bug reports should be sent via email, and questions can be directed to comp.lang.scheme or #loko on irc.libera.chat.

firstprev0next

About|Login

#compiler

Show HN: The C3 programming language (C alternative language)

Make C string literals const?

Apple M1 / M2 / M3 Core Support Might Soon Be Merged for the GCC Compiler

Vishap Oberon Compiler

Usability Improvements in GCC 15

Awe – Modern compiler for Algol W

Rust to C compiler – 95.9% test pass rate, odd platforms

Calypsi: A series of C compiler and assembly language cross compiler tool chains

Ruby: Proposal to Upstream ZJIT

Pydrofoil: Accelerating Sail-based instruction set simulators

New C++ features in GCC 15

GCC, the GNU Compiler Collection 15.1 released

ATS3 Xanadu Released

Co-dfns: High-performance, reliable, and parallel APL

COBOL front-end added to GCC

NVC: VHDL Compiler and Simulator

Using Coalton to Implement a Quantum Compiler

Scala 3.7.0 Released

Beating the fastest lexer generator in Rust

Loko Scheme, an optimizing, bare-metal Scheme compiler