Open-source alternatives to C2rust

ts-migrate is an automated migration tool designed to transform JavaScript source code into compiling TypeScript files. It functions as a code migration framework that uses abstract syntax trees to perform large-scale refactoring and structural changes across a project. The tool provides a customizable framework for defining plugin-based transformation rules, allowing for the automation of specific code changes. It includes specialized engines for converting JSDoc type definitions into native TypeScript annotations and a utility for suppressing compiler errors by inserting type assertions or

This project is a suite of abstract syntax tree transformation tools designed to automate the migration of source code to newer versions of React. It provides a set of scripts that programmatically modify code structures to replace deprecated APIs and component patterns with modern equivalents. The toolkit specializes in converting class components into functional components using arrow functions and prop destructuring. It also includes utilities for modernizing JSX syntax, updating deprecated lifecycle methods to stable versions, and migrating legacy string-based references to callback refs.

Rust-bindgen is a build-time foreign function interface binding generator and C header parser designed to automate cross-language interoperability. It functions as a tool to bridge Rust with C, C++, and Objective-C libraries by producing platform-specific declarations during the compilation process. The project distinguishes itself through its ability to handle complex C-family language constructs, including C++ inheritance and methods, as well as Objective-C classes and protocols. It ensures binary compatibility across different architectures by calculating target-aware memory layouts and va

GoGoCode is an AST-based code transformation toolkit that enables developers to query, match, and rewrite JavaScript source code using jQuery-style selectors and wildcard patterns. At its core, it provides a programmatic code refactoring library that manipulates parsed AST nodes, allowing precise structural modifications without worrying about formatting differences. The toolkit also functions as a JavaScript AST query engine, finding code patterns through snippet-based matching with wildcards that capture unknown or variable-length fragments. What distinguishes GoGoCode is its callback-drive

Include What You Use is a C++ include optimizer and header dependency analyzer. It identifies unused or missing header includes in source files to reduce project bloat and improve compilation performance. The tool performs static analysis using a Clang-based abstract syntax tree to map symbol usage and track preprocessor effects across different build configurations. It can automatically rewrite source files by inserting or deleting preprocessor directives based on the calculated dependency graph. The system integrates with compilation databases to determine the exact compiler flags used for

SQLFluff is a multi-dialect SQL linter, formatter, and style guide enforcer. It functions as a parser and analyzer that converts SQL scripts into structured trees to validate syntax, identify logical components, and enforce consistent capitalization, aliasing, and layout conventions across various database dialects. The system is specifically designed to handle templated SQL, providing the ability to analyze, parse, and lint files containing macros or placeholders. It uses dummy-parameter rendering and source mapping to validate the style and correctness of dynamic code before it is rendered

This project is a curated directory of resources, extensions, and themes designed to extend the functionality of the Visual Studio Code editor. It serves as a comprehensive index for developers seeking to enhance their coding environment, offering a structured collection of community-driven tools that streamline development workflows and improve editor productivity. The directory distinguishes itself by organizing a vast ecosystem of plugins into logical categories, ranging from language-specific intelligence and version control integrations to advanced productivity utilities. It highlights t

Transform ML models into a native code (Java, C, Python, Go, JavaScript, Visual Basic, C#, R, PowerShell, PHP, Dart, Haskell, Ruby, F#, Rust) with zero dependencies

C to Rust translator

This project is a comprehensive manual and educational resource focused on the Babel compiler. It serves as a documentation guide and handbook for understanding the inner workings of JavaScript compilation, specifically regarding the transformation of source code. The material provides a technical walkthrough for developing custom plugins and extensions. It covers the process of creating tailored transformations to modify how JavaScript is parsed and generated. The content encompasses the broader JavaScript compilation workflow, focusing on abstract syntax tree manipulation, code generation,

CoffeeScript is a source-to-source transpiler that transforms a concise high-level syntax into standard JavaScript. It enables the development of logic for web applications and server-side environments by converting source code into a format compatible with browsers and server runtimes. The project provides a workflow for rapid prototyping and script execution automation, allowing users to run source files through a compiler and execute the resulting code immediately without a manual build step. The tooling leverages lexical analysis and abstract syntax tree transformations to manipulate cod

Babel is a pluggable JavaScript compiler and transpiler that converts modern ECMAScript syntax into backwards-compatible versions of the language. It functions as an abstract syntax tree manipulator, parsing source code into a hierarchical structure to traverse and modify nodes for custom code transformations. The system utilizes a plugin-driven architecture to apply specific transformation rules and supports presets that bundle multiple plugins into named configuration groups. This enables the transformation of experimental syntax and the injection of non-global polyfills to ensure consisten

This project is a high-performance compiler written in Rust that transpiles TypeScript and ECMAScript into compatible JavaScript code. It functions as a TypeScript transpiler, a JavaScript minifier, and a JavaScript bundler. The system distinguishes itself through a WebAssembly plugin host that allows the execution of custom transformation rules without modifying the core binary. It also provides specialized compilation for React source code to improve runtime performance and reduce execution overhead. The broader capability surface includes source-to-source compilation, type annotation stri

This project is an AI coding assistant and code translator designed to convert source code from one programming language to another while preserving original logic and functionality. It functions as an intelligent interface for learning programming techniques and implementing code through guided AI support. The system includes a manager for creating and executing local autonomous AI agents to automate technical workflows and study machine learning behaviors. It also features a learning integration server that connects AI assistants with external educational content and technical context. The

Regenerator is a JavaScript generator transpiler and build-time code processor. It converts ECMAScript generator functions and asynchronous iteration into ES5 compatible state machines to ensure modern control flow works in legacy runtimes. The project functions as an ES5 compatibility transformer that rewrites advanced asynchronous patterns into standard JavaScript. It includes a runtime polyfill helper library to manage the iteration protocol and coordinate state transitions for the transpiled code. The tool provides capabilities for language transformation and asynchronous workflow polyfi

Ivy is a machine learning framework transpiler and model converter designed to ensure deep learning portability. It serves as a tool for migrating source code and models between different deep learning frameworks while maintaining original functionality. The system enables cross-framework model portability by translating model weights, architectures, and source code. It uses abstract syntax tree based transpilation and computational graph tracing to capture execution flows and rewrite high-level logic into target framework code. The project covers model interoperability through weight-layout

Lebab is a JavaScript code modernization tool that converts older ES5 syntax into contemporary ES6 equivalents. It operates as a source-to-source transpiler, parsing code into an abstract syntax tree, applying structural transformations, and regenerating the output without intermediate representations or runtime dependencies. The tool distinguishes itself through a rule-driven pipeline of independent transformation rules, each targeting a specific ES6 feature like arrow functions, let/const, classes, or modules. It provides a programmatic API that accepts source code and an array of transform

GritQL is an AST-based code transformation engine and structural search tool. It uses a declarative query language to identify and rewrite source code patterns across multiple programming languages by matching abstract syntax tree nodes rather than literal text. The system functions as an automated refactoring framework for large-scale migrations and API updates. It distinguishes itself by utilizing sequential transformation pipelines and reusable blueprints that can be synced between local environments and remote repositories. The tool covers a broad range of capabilities including static a

Borgo is a statically typed language and compiler that transforms high-level syntax into Go source code. It functions as a transpiler designed to leverage the Go runtime while introducing a type system centered on algebraic data types and result-based error handling. The language distinguishes itself by replacing Go's multiple return values with result and option types, using a dedicated operator for concise error propagation. It implements sum types with exhaustive pattern matching and provides a tool to generate bindings for existing Go packages, automatically converting multi-value returns

Backpack is a Node.js build system designed for transpiling, bundling, and automating the development workflow. It functions as a JavaScript asset bundler that packages source files and dependencies into optimized output for production deployment. The system integrates a transpilation process to convert modern code into versions compatible with various environments and browsers. It provides an automated development workflow that watches for file changes to trigger automatic reloads and builds. The build pipeline supports configuration-driven customization, environment-specific targets, and i

Ivy is a machine learning framework transpiler and model converter designed to translate code and computational graphs between different deep learning ecosystems. It serves as a portability tool for migrating model architectures and logic across competing frameworks to enable flexible deployment. The system achieves cross-framework conversion by utilizing abstract syntax tree analysis to rewrite source code and by employing a computational graph tracer to capture tensor flows and operation sequences during live execution. This process allows for the translation of both high-level model defini

Rollup is an ES module bundler and JavaScript module transpiler. It functions as a build tool that combines JavaScript modules into optimized files and converts modern JavaScript and JSX into various output formats for different runtime environments. The project is distinguished by its static-analysis tree shaking engine, which removes unused code and dead exports to minimize bundle size. It also acts as a code splitting orchestrator, partitioning modules into separate chunks to optimize network requests and load times. The tool provides a hook-based plugin system for extending build logic,

Grumpy is a native binary compiler that transforms Python source code into Go source code. By transpiling high-level scripts into a strongly typed intermediate representation, the system enables the creation of statically linked native binaries that operate independently of a traditional virtual machine interpreter. The project distinguishes itself by providing a comprehensive runtime library that replicates standard Python data structures and object behaviors. This emulation layer ensures that compiled code maintains functional parity with the original source environment while leveraging the

Vis is a terminal-based modal text editor that utilizes vi keybindings and a system of structural regular expressions. It functions as a scriptable environment where Lua is used for configuration, custom key mappings, and plugin development. The editor distinguishes itself through a syntax highlighting system based on Parsing Expression Grammars and a pattern matching engine that treats text as a structure for complex search and replace operations. It also integrates directly with the system shell, allowing users to pipe text ranges to external commands and capture the resulting output. The

Memgraph is an in-memory, distributed graph database designed for high-performance labeled property graph management. It utilizes a Cypher query engine for declarative data retrieval and manipulation, providing a scalable knowledge graph backend that integrates vector search and graph traversals. The system distinguishes itself as a real-time graph analytics platform, employing native C++ and CUDA implementations to execute complex network analysis and dynamic community detection on streaming data. It provides specialized support for AI integration, including GraphRAG capabilities, the constr

Utopia is a development platform for building React components through a visual interface that synchronizes changes directly with underlying source code. It functions as an AST-based code editor and a visual component editor, using abstract syntax tree manipulation to update files while preserving the original formatting and structure. The project features an in-browser module bundler that compiles and executes JavaScript modules directly within the browser to provide immediate feedback without server-side build steps. It also includes a pull request preview tool for inspecting and validating

gptel is an LLM Emacs client and multi-backend AI integration system that allows users to interact with large language models directly inside the Emacs text editor. It serves as an AI-powered text refactoring tool and a context-aware prompt manager, providing a unified interface to connect with various AI providers, including local Ollama instances, AWS Bedrock, and Gemini. The project distinguishes itself as a Model Context Protocol client, connecting to MCP servers to provide language models with external tools and data sources. It enables context-augmented prompting by aggregating text fro