awesome-repositories.com
Blog
awesome-repositories.com

Entdecke die besten Open-Source-Repositories mit KI-gestützter Suche.

EntdeckenKuratierte SuchenOpen-Source-AlternativenSelf-hosted SoftwareBlogSitemap
ProjektÜber unsRanking-MethodikPresseMCP-Server
RechtlichesDatenschutzAGB
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·

18 Repos

Awesome GitHub RepositoriesExternal Module Declarations

Build-time configurations that map internal module imports to global variables provided by the browser environment.

Distinguishing note: Shortlist candidates focus on system variables, linters, or C-interop, not JS bundler externals.

Explore 18 awesome GitHub repositories matching development tools & productivity · External Module Declarations. Refine with filters or upvote what's useful.

Awesome External Module Declarations GitHub Repositories

Finde die besten Repos mit KI.Wir suchen mit KI nach den am besten passenden Repositories.
  • jaredpalmer/tsdxAvatar von jaredpalmer

    jaredpalmer/tsdx

    11,471Auf GitHub ansehen↗

    tsdx is a zero-config command line interface and build tool designed for developing, bundling, and distributing TypeScript libraries. It functions as a project scaffolder and development toolchain that initializes new libraries from templates with standardized folder structures and pre-configured dependencies. The project specializes in producing dual-format module distributions, simultaneously generating both CommonJS and ES modules to ensure compatibility across different JavaScript environments. It utilizes a Rollup-based bundling system to compile TypeScript source into optimized distribu

    Produces TypeScript type definition files from source code to ensure consistent data structures for package consumers.

    TypeScriptbundlingjestnpm
    Auf GitHub ansehen↗11,471
  • ruanyf/webpack-demosAvatar von ruanyf

    ruanyf/webpack-demos

    9,571Auf GitHub ansehen↗

    This repository is a collection of Webpack configuration examples and JavaScript module bundler demonstrations. It provides asset pipeline tutorials and frontend build tool examples focused on resolving dependencies and merging multiple modules into optimized browser files. The project demonstrates how to configure Webpack for transforming JavaScript assets, including the use of loaders and plugins to process JSX, CSS, and images into browser-ready formats. It includes practical examples of code splitting, minification, and environment variable injection. The covered capabilities include fro

    Marks modules as externals to prevent bundling and allow access via shared global variables at runtime.

    JavaScript
    Auf GitHub ansehen↗9,571
  • seajs/seajsAvatar von seajs

    seajs/seajs

    8,270Auf GitHub ansehen↗

    SeaJS is a client-side JavaScript module loader and dependency manager. It provides a system for resolving and loading isolated JavaScript files as modules, ensuring that internal and external code requirements are met before execution. The project distinguishes itself as a pluggable asset loader, utilizing a plugin system to load and integrate non-JavaScript assets, such as stylesheets and text files, directly into the module workflow. The system handles frontend dependency resolution through dependency-graph tracking and dynamic path resolution. It manages code organization via isolated mo

    Provides a system for declaring internal and external requirements for a module to ensure necessary code is available before execution.

    JavaScript
    Auf GitHub ansehen↗8,270
  • umdjs/umdAvatar von umdjs

    umdjs/umd

    7,447Auf GitHub ansehen↗

    This project provides a universal module definition pattern and JavaScript module wrapper. It establishes a standardized methodology for distributing JavaScript libraries that function across CommonJS, AMD, and browser global environments. The system uses an adapter approach to bridge different module systems, allowing a single file to operate in both Node.js and client-side browser environments without modification. This includes specific patterns for creating jQuery plugins that maintain compatibility across modular loaders and global scopes. The codebase implements environment-detection l

    Ensures JavaScript modules can be loaded in CommonJS, AMD, and browser environments using a standardized wrapper.

    JavaScript
    Auf GitHub ansehen↗7,447
  • dtolnay/cxxAvatar von dtolnay

    dtolnay/cxx

    6,664Auf GitHub ansehen↗

    CXX is a code generator that produces a safe, zero-overhead FFI bridge between Rust and C++. It lets functions and data types from either language be used directly in the other, with static type safety enforced at compile time and no copying, serialization, or runtime checks across the boundary. The bridge supports the full range of cross-language interactions: Rust can call C++ functions and use C++ types, and C++ can call Rust functions and use Rust types. Standard library types like strings, vectors, and smart pointers are mapped automatically between the two languages, while opaque types

    Replaces raw extern C declarations with richer, type-safe FFI interfaces between Rust and C++.

    Rust
    Auf GitHub ansehen↗6,664
  • rust-lang/rfcsAvatar von rust-lang

    rust-lang/rfcs

    6,406Auf GitHub ansehen↗

    The Rust RFCs repository is the formal home for the Rust language evolution process, housing the structured design documents and community review mechanisms that govern changes to the Rust programming language, its compiler, and its standard library. It defines the complete lifecycle for proposing, discussing, and implementing substantial changes through RFC documents, from initial submission and community feedback through final comment periods and sub-team sign-offs. The repository codifies the governance and collaboration processes that shape Rust's development, including mechanisms for com

    Permits extern crate declarations inside block expressions and function bodies for flexible module scoping.

    Markdownrfcrfc-processrust
    Auf GitHub ansehen↗6,406
  • cue-lang/cueAvatar von cue-lang

    cue-lang/cue

    6,147Auf GitHub ansehen↗

    CUE is a constraint-based configuration language designed for data validation, schema definition, and code generation. At its core, it unifies types and values into a single concept, enabling compile-time validation that catches structural and value errors before runtime. The language treats data and constraints as the same thing, allowing a single definition to serve as both a schema and concrete configuration data. CUE distinguishes itself through its constraint-based unification engine, which combines multiple configuration sources into a single coherent result by merging their constraints

    Declares and resolves external module dependencies for sharing definitions across projects.

    Goconfigurationdatakubernetes
    Auf GitHub ansehen↗6,147
  • cortexproject/cortexAvatar von cortexproject

    cortexproject/cortex

    5,751Auf GitHub ansehen↗

    Cortex is an open-source, horizontally scalable metrics platform that ingests, stores, and queries Prometheus-compatible time-series data with multi-tenant isolation. It accepts metrics via Prometheus remote write and OpenTelemetry, executes PromQL queries against both recent and historical data, and provides a Prometheus-compatible alerting and recording rule engine with an integrated Alertmanager. The system is built as a set of independently scalable microservices that use hash-ring-based sharding, gossip-based cluster membership, and tenant-aware object storage to distribute workloads acro

    Cortex specifies which modules must be initialized before a given module, ensuring correct startup order.

    Gocncfhacktoberfestkubernetes
    Auf GitHub ansehen↗5,751
  • standard-things/esmAvatar von standard-things

    standard-things/esm

    5,245Auf GitHub ansehen↗

    esm is an ECMAScript module loader and JavaScript module path resolver. It functions as a runtime system that executes standard JavaScript modules without requiring a separate build or bundling process. The project provides a compatibility bridge for CommonJS interoperability, wrapping CommonJS exports into synthetic modules to allow imports and exports between different module systems. It includes a dynamic module cache that stores resolved instances in memory to prevent redundant file system reads and repeated execution. The system handles runtime path resolution and file extension detecti

    Wraps CommonJS exports into synthetic ECMAScript modules to enable seamless interoperability between different module systems.

    JavaScriptes6es6-modulesesm
    Auf GitHub ansehen↗5,245
  • rhinosecuritylabs/pacuAvatar von RhinoSecurityLabs

    RhinoSecurityLabs/pacu

    5,234Auf GitHub ansehen↗

    Pacu ist ein Exploitation-Framework, das für das Auditieren und Testen der Sicherheit von Amazon Web Services (AWS)-Umgebungen entwickelt wurde. Es dient als Cloud-Penetration-Testing-Tool und Ressourcen-Enumerator, um Fehlkonfigurationen zu identifizieren, Angriffsflächen abzubilden und Pfade zur Privilegieneskalation auszuführen. Das Framework bietet spezialisierte Funktionen für Post-Exploitation- und Red-Team-Operationen, einschließlich der Etablierung von Persistenz durch Backdooring von Identity and Access Management (IAM). Es zeichnet sich durch ein Plugin-basiertes Modulsystem aus, das die Entwicklung benutzerdefinierter Aufgaben und die Orchestrierung von API-Anfragen über mehrere geografische Regionen hinweg ermöglicht. Das Projekt deckt ein breites Spektrum an Sicherheitsaudit-Aktivitäten ab, einschließlich Infrastruktur-Enumeration, Datenexfiltration aus Speicherdiensten und Identitäts-Audits. Es enthält Tools für Remote Code Execution via Payload-Injection und Startskripte sowie Funktionen zur Störung von Erkennungsdiensten und zur Analyse lateraler Netzwerkbewegungen. Pacu verwaltet zielspezifische Authentifizierungsschlüssel und Sitzungsmetadaten unter Verwendung isolierter Container und einer lokalen Datenbank, um den Status beizubehalten und API-Aufrufe zu reduzieren.

    Ensures modules are executed in the correct order by resolving data dependencies first.

    Python
    Auf GitHub ansehen↗5,234
  • rust-lang/rust-bindgenAvatar von rust-lang

    rust-lang/rust-bindgen

    5,212Auf GitHub ansehen↗

    Rust-bindgen ist ein Build-Time-Generator für Foreign Function Interface (FFI)-Bindings und ein C-Header-Parser, der entwickelt wurde, um die Interoperabilität zwischen Sprachen zu automatisieren. Er fungiert als Tool, um Rust mit C-, C++- und Objective-C-Bibliotheken zu verbinden, indem er während des Kompilierungsprozesses plattformspezifische Deklarationen erstellt. Das Projekt zeichnet sich durch seine Fähigkeit aus, komplexe Sprachkonstrukte der C-Familie zu verarbeiten, einschließlich C++-Vererbung und -Methoden sowie Objective-C-Klassen und -Protokolle. Es stellt die binäre Kompatibilität über verschiedene Architekturen hinweg sicher, indem es zielspezifische Speicherlayouts berechnet und validiert, dass die generierten Strukturgrößen und Alignments mit den ursprünglichen Quelldefinitionen übereinstimmen. Das Tool bietet umfangreiches Typ-Mapping für C-Unions, Bitfields und flexible Array-Member, während nicht übersetzbare oder komplexe Standardbibliothekstypen auf opake Byte-Blobs abgebildet werden. Es enthält ein Konfigurationssystem zum Filtern von Bindings, zum Ersetzen komplexer Typen und zur Steuerung der Trait-Ableitung oder Feldsichtbarkeit. Generierte Bindings können extrahierte Dokumentationen aus System-Headern enthalten und werden durch einen Standard-Formatter verarbeitet, um ein konsistentes Code-Styling sicherzustellen.

    Generates type-safe cross-language interface declarations from both C and C++ header files.

    Rustbindingscodegenffi
    Auf GitHub ansehen↗5,212
  • sofastack/sofa-bootAvatar von sofastack

    sofastack/sofa-boot

    5,069Auf GitHub ansehen↗

    Sofa-boot ist ein modulares Java-Anwendungsframework und eine Spring Boot-Erweiterung, die entwickelt wurde, um Anwendungsmodule in getrennte Ausführungskontexte zu isolieren. Es bietet einen JVM-Service-Orchestrator zum Veröffentlichen und Referenzieren interner Dienste sowie eine Integrationsschicht für Unternehmens-Middleware zur Bereitstellung in sich geschlossener Middleware-Starter. Das Framework verhindert Bean-, Konfigurations- und Abhängigkeitsversionskonflikte durch die Verwendung unabhängiger Classloader und eines hierarchischen Baums distinkter Ausführungskontexte. Es optimiert die Startzeiten von Unternehmensanwendungen, indem unabhängige Module parallel geladen und Komponenten asynchron initialisiert werden. Das System enthält einen Verifizierer für die Anwendungsbereitschaft, der externen Netzwerkverkehr und die Dienstregistrierung blockiert, bis alle Komponenten vollständig initialisiert sind. Es verwaltet zudem die Service-Orchestrierung, indem es interne Modulkommunikation in Remote-Service-Aufrufe umwandelt und Middleware- sowie SDK-Logging-Streams von den primären Anwendungsprotokollen entkoppelt.

    Defines how modules expose capabilities and consume dependencies through explicit service and reference declarations.

    Javasofa-bootsofa-boot-startersofastack
    Auf GitHub ansehen↗5,069
  • libigl/libiglAvatar von libigl

    libigl/libigl

    5,030Auf GitHub ansehen↗

    libigl is a C++ geometry processing library used for analyzing and manipulating 3D triangle and tetrahedral meshes. It functions as a numerical linear algebra suite and a mesh manipulation framework, integrating a geometric deformation engine to implement rigid and polyharmonic transformations. The project is distinguished by its header-only library design and its implementation of specialized deformation techniques, including rigid-as-possible and polyharmonic shape deformation. It also provides a visualization tool for rendering surfaces and scalar fields with interactive scene controls and

    Allows configuring specific geometry processing modules in a build system via configuration files.

    C++
    Auf GitHub ansehen↗5,030
  • ecomfe/specAvatar von ecomfe

    ecomfe/spec

    4,605Auf GitHub ansehen↗

    Spec ist ein umfassendes Set an Frontend-Coding-Standards und Architekturleitfäden für Projekte. Es bietet ein Framework zur Organisation von Verzeichnisstrukturen, Modulabhängigkeiten und Paket-Layouts, um skalierbare und vorhersehbare Codebasen zu erstellen. Das Projekt definiert strenge Governance-Standards für React-Komponenten, einschließlich spezifischer Namenskonventionen und struktureller Muster für Props. Zudem etabliert es eine JSON-API-Datenspezifikation, um eine vorhersehbare Kommunikation zwischen Systemkomponenten durch standardisierte Austauschformate und HTTP-Antwortstrukturen zu gewährleisten. Die Spezifikation deckt ein breites Spektrum an Funktionen ab, einschließlich Web-Accessibility-Compliance durch semantisches HTML und barrierefreie Formularsteuerelemente sowie Strategien zur Web-Performance-Optimierung für DOM-Manipulation und Ressourcen-Laden. Sie detailliert zudem Standards für JavaScript-, HTML- und CSS-Coding-Styles, um Konsistenz über Entwicklungsteams hinweg zu wahren.

    Distinguishes between internal module references and external package dependencies to maintain clean loading paths.

    Auf GitHub ansehen↗4,605
  • ergo-services/ergoAvatar von ergo-services

    ergo-services/ergo

    4,441Auf GitHub ansehen↗

    Ergo is a distributed actor framework for Go that implements the Erlang distribution protocol, enabling the construction of resilient, concurrent applications that can communicate transparently with Erlang/OTP nodes. At its core, it provides an actor model with isolated lightweight processes, priority-ordered mailboxes, and a meta-process architecture that separates blocking I/O from sequential message handling to prevent actor freezing. The framework includes a Raft-inspired cluster consensus system for leader election and automatic failover, along with OTP-style supervision trees that organi

    Ensures that required applications or services are running before starting the current application.

    Goactor-modelactorsdistributed
    Auf GitHub ansehen↗4,441
  • rollup/pluginsAvatar von rollup

    rollup/plugins

    3,750Auf GitHub ansehen↗

    This is a collection of official extensions for the Rollup bundling process. These plugins serve as module transformers, resolution managers, and bundle optimizers designed to modify how JavaScript modules are processed, resolved, and optimized. The suite provides specialized capabilities for modern web transpilation, converting TypeScript, JSX, Flow, and GraphQL into compatible JavaScript. It distinguishes itself through extensive non-JavaScript asset integration, allowing the import of JSON, YAML, CSV, and image files as JavaScript modules or data URIs, and providing support for bundling We

    Locates third-party libraries and manages module path resolution to ensure dependencies are correctly bundled.

    JavaScriptpluginsrolluprollup-plugins
    Auf GitHub ansehen↗3,750
  • nixos/nix.devAvatar von NixOS

    NixOS/nix.dev

    3,630Auf GitHub ansehen↗

    This project provides a functional package manager and a reproducible build system designed to ensure identical build inputs always produce the same outputs. It serves as the foundation for a declarative Linux distribution where the entire system state is defined in a configuration file, enabling predictable deployments and full-system rollbacks. The system uses a deterministic functional language and a lazy-evaluation expression engine to manage software dependencies and isolate build environments. It distinguishes itself through a content-addressable store that allows multiple versions of s

    Specifies requirements between configuration modules to ensure a correct order of evaluation.

    Nixcookbookdocumentationlearning
    Auf GitHub ansehen↗3,630
  • rolldown/tsdownAvatar von rolldown

    rolldown/tsdown

    3,453Auf GitHub ansehen↗

    tsdown is a library bundler that uses a Rust-native core, built on Rolldown and the Oxc parser, to compile TypeScript and JavaScript source code into optimized output files. It is designed to produce bundles in multiple formats—ESM, CJS, IIFE, and UMD—from a single source, and automatically generates TypeScript declaration files during the build process for type-safe distribution. The project distinguishes itself by offering a plugin system compatible with Rollup, Rolldown, unplugin, and some Vite plugins, allowing the build pipeline to be extended with custom transformations. It also accepts

    Generates TypeScript declaration files (.d.ts) during the build process using a built-in declaration emitter.

    TypeScriptbundlerlibraryoxc
    Auf GitHub ansehen↗3,453
  1. Home
  2. Development Tools & Productivity
  3. External Module Declarations

Unter-Tags erkunden

  • Block-Level Extern Crate DeclarationsAllows extern crate declarations inside block expressions and function bodies, not only at module level. **Distinct from External Module Declarations:** Distinct from External Module Declarations: focuses on Rust-specific block-level extern crate syntax, not general build-time module mappings.
  • FFI Declaration Generators1 Sub-TagGenerates richer FFI declarations that replace raw extern C signatures with type-safe cross-language interfaces. **Distinct from External Module Declarations:** Distinct from External Module Declarations: generates C++ FFI declarations from Rust, not JS bundler externals.
  • Runtime Module Declarations3 Sub-TagsMechanisms for declaring module dependencies at runtime to ensure prerequisites are met before execution. **Distinct from External Module Declarations:** Focuses on runtime dependency declaration rather than build-time configuration mappings to global variables.