Projects sharing features with Bazel

Julia is a high-performance, dynamic programming language designed for scientific computing, data analysis, and complex mathematical modeling. It provides a specialized runtime environment that manages memory allocation and parallel processing, utilizing a just-in-time compiler to translate high-level source code into optimized machine instructions. This architecture allows the language to achieve execution speeds comparable to statically compiled languages while maintaining the flexibility of a dynamic scripting environment. The language is distinguished by its multiple dispatch system, whic

This project is a comprehensive C++ unit testing framework designed to verify code logic and identify regressions through a suite of assertion macros, test fixtures, and execution runners. It automates the discovery and registration of test cases during static initialization, allowing developers to define isolated test environments that ensure repeatable and predictable conditions for every execution. The framework distinguishes itself through a sophisticated mock object library that enables the simulation of components and the enforcement of strict interaction requirements. By intercepting v

Twenty is a headless customer relationship management framework that enables developers to build, version, and deploy custom business applications using code. By utilizing a declarative approach to data modeling, the platform allows for the definition of custom objects, fields, and complex relationships directly within the source code. This schema-driven architecture automatically generates corresponding REST and GraphQL APIs, ensuring that data structures and interface components remain synchronized across development and production environments. The platform distinguishes itself through a m

Cargo is the official build system and package manager for the Rust programming language. It provides a unified command-line interface that orchestrates the entire development lifecycle, including compiling source code, managing complex dependency graphs, running tests, and distributing packages through a centralized registry. By utilizing declarative manifest files, it ensures that builds remain reproducible and consistent across different environments. The tool distinguishes itself through its deep integration with the Rust compiler and its sophisticated approach to project management. It f

Redox is a POSIX-compliant, microkernel-based operating system written entirely in Rust. By utilizing a memory-safe language for the kernel and all system components, the project eliminates common vulnerabilities such as buffer overflows and use-after-free errors. Its architecture relies on a minimal kernel that manages only essential hardware and process isolation, delegating all other system services to unprivileged user-space processes. The system distinguishes itself through a modular design where hardware drivers and system services run as independent user-space daemons, allowing them to

Gulp is a JavaScript build automation tool and Node.js task runner designed to coordinate the execution of development tasks. It operates as a streaming build system that transforms source files into production assets through a series of programmable pipelines. The system functions as a file watcher and task orchestrator, monitoring directories for modifications to automatically trigger specific build tasks. It organizes these units of work into sequential or parallel execution paths to streamline development workflows. The toolkit manages asset pipelines by reading files via pattern matchin

Zig is a general-purpose systems programming language designed for high-performance applications that require manual memory management and direct control over hardware resources. It prioritizes predictable execution by enforcing explicit control flow and requiring functions to accept explicit memory allocators, ensuring that all heap operations and logic paths remain visible to the developer. The language distinguishes itself through a powerful compile-time metaprogramming engine that allows for arbitrary code execution during the build process, enabling advanced reflection and the generation

This project is a cross-platform package manager designed to automate the acquisition, compilation, and integration of third-party software libraries into native development projects. It functions as a manifest-driven dependency manager, utilizing declarative configuration files to define project requirements and resolve them into consistent, versioned dependency graphs across Windows, Linux, and macOS. The system distinguishes itself through port-based build automation, which uses standardized scripts to fetch, patch, and compile source code, and triplets-based configuration files that encap

MSBuild is a task-based build engine and programmatic framework used to compile and package .NET applications. It functions as a customizable orchestrator that executes sequences of targets to automate software compilation and deployment workflows using a structured XML-based configuration schema. The system allows for the creation of custom build tasks and reusable rules to handle unique compilation requirements. It supports multi-target framework development, enabling a single codebase to be compiled against various runtime versions to ensure compatibility across different platforms. The e

Nuke is a build automation system for defining software compilation and deployment pipelines using a strongly typed C# console application. It functions as a cross-platform build engine and pipeline orchestrator that treats build configurations as standard executable programs rather than static files. By leveraging a compiled language, the system provides type safety and IDE support for build script logic. This approach allows for the definition of automation and CI/CD pipelines using a professional programming language instead of YAML or shell scripts. The engine manages .NET project orches

Moon is a monorepo build system and task runner designed to orchestrate complex projects with multiple packages. It functions as a dependency graph orchestrator that executes build targets in topological order and utilizes input hashing to cache results and skip redundant work. The project features a polyglot toolchain manager that automates the installation and versioning of language runtimes and CLI tools to ensure environment consistency. It also includes a plugin framework based on WebAssembly, allowing developers to extend build logic and toolchain behavior using any supported language.

ModernCppStarter is a pre-configured project boilerplate and bootstrapping environment for C++ libraries and executables. It provides a standardized set of CMake build configurations and templates to automate the initialization of new projects. The project integrates a comprehensive static analysis suite and documentation automation. It includes systems for enforcing code quality through sanitizers and analyzers, as well as a pipeline for generating and deploying technical documentation during project releases. The template covers broader development infrastructure, including dependency mana

This project is a containerized build automation system and self-hosted DevOps platform provided as a Docker image. It serves as a distributed build orchestrator and a Dockerized continuous integration and delivery server, ensuring consistent execution environments across different infrastructure. The system distinguishes itself through a distributed execution model that separates a primary controller from multiple remote agents connected via SSH, TCP, or web sockets. It utilizes a modular extensibility framework that allows the core system functionality to be augmented through the installati

Poetry is a comprehensive dependency manager and packaging tool for Python projects. It functions as a configuration engine that resolves complex dependency graphs, manages isolated virtual environments, and ensures reproducible builds through deterministic lock file generation. By centralizing project metadata and build requirements into a single configuration file, it provides a unified workflow for managing the entire lifecycle of a Python codebase. The project distinguishes itself through its constraint-based solver, which evaluates environment markers and version requirements to maintain

Flox is a Nix environment manager designed to create, share, and maintain reproducible software stacks. It uses declarative manifests to isolate project dependencies and toolchains, ensuring identical runtimes across different machines and operating systems. The platform distinguishes itself by enabling the deployment of imageless workloads to Kubernetes, allowing software to run in pods without traditional container images. It can also synthesize OCI-compliant container images and distroless artifacts directly from declarative environment definitions. The project covers broad capability are

This project provides a comprehensive set of architectural patterns, build configurations, and quality standards for developing maintainable and scalable Android applications. It serves as a guide for organizing mobile application code into feature-based modules to improve encapsulation and simplify navigation, while establishing a framework for standardizing build processes and dependency management across development environments. The repository distinguishes itself by offering strategies for integrating automated quality assurance, including unit testing, static code analysis, and performa

Bun is a high-performance runtime environment designed to execute JavaScript and TypeScript applications with minimal latency and high throughput. Built on a native core implemented in Zig, it provides a unified execution engine that leverages JavaScriptCore for efficient memory management and low-latency startup. The project functions as an all-in-one toolchain, integrating a native bundler, transpiler, package manager, and test runner into a single command-line interface. What distinguishes Bun is its focus on native system integration and developer productivity. It features a high-performa

Kitty is a high-performance, GPU-accelerated terminal emulator designed to provide a consistent and extensible workspace across different operating systems. It leverages graphics hardware to render text, images, and complex layouts with low latency, while providing a robust environment for demanding command-line workflows. The project distinguishes itself through its integrated workspace management and programmable interface. It functions as a tiling window manager that organizes terminal windows, tabs, and layouts into persistent, keyboard-driven sessions. Users can automate complex workflow

OpenClash is a network traffic controller designed for embedded router hardware. It functions as a kernel-level traffic management solution that intercepts network packets to enforce user-defined routing policies and connectivity rules across home or office network environments. The project distinguishes itself through a comprehensive build and deployment pipeline tailored for diverse firmware architectures. It provides a cross-compilation environment that transforms source code into hardware-specific installation files, while also offering a package management system to handle the retrieval

Go is a statically typed, compiled programming language designed for building scalable, concurrent software. It provides a memory-safe execution environment that combines a high-performance runtime with a self-hosting compiler toolchain, enabling the creation of statically linked machine code binaries without external dependencies. The language is built around a structural type system that uses interfaces for polymorphism and a concurrency model based on lightweight, stack-based coroutines that communicate through channels. The language distinguishes itself through a runtime that features a c

F Prime is a component-based framework designed for the development and deployment of embedded and spaceflight software. It provides a modular architecture that decouples software logic from communication interfaces, allowing developers to define system structures through a domain-specific modeling language. This model-based approach enables automated code generation, ensuring consistency across complex system topologies while maintaining strict interface contracts between software modules. The framework distinguishes itself through its integrated build system and ground data operations suite

Btop is a terminal-based system monitor that tracks and displays real-time hardware performance metrics. It functions as a resource usage dashboard, providing visibility into processor, memory, disk, network, and active process activity directly within a text-based interface. The application utilizes ANSI escape sequences to render complex graphical interfaces and data visualizations within standard terminal emulators. It is designed as a cross-platform performance tool, maintaining consistent monitoring capabilities across various Unix-like operating systems through a platform-agnostic build

Gradle is a build automation tool for the Java Virtual Machine that functions as a polyglot build orchestrator. It automates the compilation, testing, and packaging of software across multiple programming languages using a structured workflow. The project acts as a build performance optimizer, utilizing daemon processes, parallel execution, and result caching to reduce redundant computation. It also serves as a dependency management system that resolves external libraries and plugins while verifying checksums to ensure integrity. The system coordinates complex build lifecycles and task depen

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

Neovim is a text editing environment designed for extensibility and performance. It provides a core engine for text manipulation, multi-window management, and complex editing commands, while maintaining compatibility with existing paradigms. The project features a stable interface that allows external clients to interact with the application state, enabling the development of custom user interfaces and integrated tools. The architecture decouples the core editing logic from the user interface through an asynchronous protocol. This system supports external rendering processes, including termin

This project serves as a comprehensive language ecosystem index, functioning as a centralized, community-curated directory for the Go programming language. It organizes a vast landscape of software components, libraries, and development tools into a structured, navigable hierarchy, enabling developers to efficiently discover resources tailored to specific functional domains. The repository distinguishes itself through a decentralized contribution model, where community-driven updates ensure the index remains current with the rapidly evolving software landscape. Beyond simple resource listing,

This project is a comprehensive, community-curated directory that organizes a vast landscape of Python software libraries, frameworks, and tools. It serves as a centralized knowledge base designed to facilitate ecosystem navigation and accelerate developer discovery across the entire software development lifecycle. The directory distinguishes itself by providing a structured index of resources categorized by technical domain, ranging from foundational development utilities to specialized engineering fields. It covers high-level capabilities including artificial intelligence, data science, web