awesome-repositories.com
博客
MCP
awesome-repositories.com

通过 AI 驱动的搜索，发现最优秀的开源仓库。

探索精选搜索开源替代品自托管软件博客网站地图
项目MCP 服务器关于排名机制媒体报道
法律隐私政策服务条款
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
janet-lang avatar

janet-lang/janet

0
View on GitHub↗
4,308 星标·264 分支·C·MIT·5 次浏览janet-lang.org↗

Janet

Janet is a Lisp-based dynamic programming language featuring a register-based bytecode virtual machine and an embeddable scripting engine. It functions as a fiber-based concurrency runtime and includes a parsing engine based on Parsing Expression Grammars.

The project is distinguished by its ability to be integrated into C or C++ applications via a minimal header interface. It utilizes a Lisp-style macro system for compile-time code transformation and employs prototype-based table inheritance for object-oriented behavior.

The runtime covers a broad set of capabilities, including asynchronous IO management through a non-blocking event loop, native library interoperability via a foreign function interface, and comprehensive text processing using PEG grammars. It also provides tools for system automation, such as a read-eval-print loop, a module system for symbol resolution, and utilities for network socket communication and file system management.

The environment includes diagnostic tools for bytecode execution debugging and can bundle source code into standalone binary executables.

Features

  • Register-Based Execution - Implements a register-based bytecode virtual machine that executes a custom 32-bit instruction set.
  • Register-Based VMs - Implements a dynamic programming language powered by a register-based bytecode virtual machine.
  • C-Embeddable Runtimes - The project integrates a dynamic language runtime into C or C++ programs using headers.
  • Register-Based Bytecode - Features a register-based bytecode virtual machine to minimize stack operations and improve performance.

AI 搜索

探索更多 awesome 仓库

用简单的语言描述您的需求 —— AI 将根据相关性为您从数千个精选开源项目中进行排序。

Start searching with AI
  • File and Directory Management - Provides tools for listing directory contents, renaming files, and modifying file system permissions.
  • PEG-Based Parse Dialects - Uses PEG grammars and macros to analyze complex text and automate code patterns during compilation.
  • Custom Text Format Parsing - Employs a formal grammar engine to robustly extract structured data from complex text.
  • Macro-Based Code Transformations - Uses macros to transform source code and automate repetitive programming patterns at compile time.
  • Non-Blocking TCP Servers - Implements non-blocking TCP sockets to create reliable byte streams between clients and servers.
  • Socket Communication - Provides low-level TCP and UDP socket communication integrated with a non-blocking event loop.
  • TCP Server Implementations - Provides a TCP server implementation that manages concurrent clients via an asynchronous event loop.
  • Native Function Invocations - Enables the invocation of exported functions from shared native C libraries to access system capabilities.
  • Associative Arrays - Implements fundamental associative arrays that combine indexed lists and keyed dictionaries for data manipulation.
  • Associative Table Management - Provides flexible tables that serve as lists, dictionaries, and sets with prototype-based inheritance.
  • Runtime Embedding - Embeds the entire language runtime into larger native C or C++ projects as a component.
  • Hash Table Lookups - Utilizes hash tables to associate keys with values, ensuring constant-time lookup performance.
  • Runtime Symbol Resolution - Provides mechanisms for loading and resolving external symbols across modules during program execution.
  • Conditional Logic - Implements standard execution flow control using boolean expressions, if-else constructs, and switch chains.
  • Conditional Loop Execution - Provides iterative structures that repeat code blocks as long as a specific boolean condition remains true.
  • Dynamic Native Invocation - Enables calling functions from external dynamic libraries via runtime lookup without requiring static interface definitions.
  • Embedded Scripting Engines - Provides a dynamic language runtime and bytecode VM that can be embedded into C or C++ applications.
  • File Read and Write Operations - Provides standard library primitives for opening, seeking, reading, and writing local files.
  • Function Definitions - Supports creating reusable logic via named definitions and anonymous literals treated as first-class values.
  • Variadic and Optional Arguments - Handles varying input requirements using optional parameters, default values, and variadic tuples.
  • Lightweight Process Management - Uses fibers as low-overhead lightweight processes to execute multiple concurrent execution flows.
  • Macro Expansion Engines - Implements a macro expansion engine that transforms source code during the compilation phase.
  • Foreign Function Interfaces - Maps native C types to language values to enable direct invocation of external libraries and system functions.
  • Native C Interoperability - Provides interfaces for calling C and C++ functions from the language runtime to interoperate with native libraries.
  • Lisp Runtimes - Implements a Lisp-based language with a powerful macro system and an interactive REPL.
  • Metaprogramming & Macros - Provides a macro system that creates new language constructs by transforming code during compilation.
  • Native Symbol Mapping - Maps native types to language values by resolving symbols from dynamic libraries at runtime.
  • Non-blocking IO Implementations - Implements asynchronous input and output using a non-blocking event loop and streams.
  • Prototype-Based Inheritance - Implements an object-oriented model where tables inherit properties and behavior directly from prototypes.
  • Scripting Runtimes - Provides an embeddable language interpreter and runtime to execute dynamic scripts and user-defined logic.
  • Source Code Modularization - Organizes code by grouping related bindings into separate files to manage namespaces and maintainability.
  • Standard Libraries - Ships a comprehensive standard library of functions for essential programming tasks like I/O and collection management.
  • Symbol Bindings - Assigns names to values using immutable or mutable bindings to manage data.
  • Variable Scope Management - Manages variable visibility and lifetime using blocks and closures to control scope.
  • VM Embedding Interfaces - Integrates a bytecode VM and runtime into host applications through a minimal header interface.
  • Asynchronous Task Managers - Manages concurrent IO-bound operations and non-blocking schedules using fibers and an event loop.
  • Iterative Loop Constructs - Implements language-level loop constructs and list comprehensions for generating sequences.
  • Fiber-Based Concurrent Execution - Manages lightweight, non-blocking fibers that yield and resume to handle concurrent IO-bound tasks.
  • Suspendable Execution - Controls asynchronous task flow by suspending and resuming fibers while tracking their execution state.
  • Foreign Function Interfaces - Integrates native code into scripts by defining function signatures and managing memory pointers via a foreign function interface.
  • PEG Grammar Parsers - Includes a formal grammar engine based on Parsing Expression Grammars for structured text extraction.
  • Compile-Time Metaprogramming - Enables computations and code transformations during the compilation phase via a powerful macro system.
  • Asynchronous Event Loops - Implements a fiber-based event loop to coordinate non-blocking input and output operations.
  • Collection Filtering and Mapping - Provides mapping and filtering operations to process sequences and create derived arrays.
  • Binary Data Buffers - Implements byte array and buffer management for pushing bytes or numeric types onto raw binary buffers.
  • Byte Buffers - Provides raw memory buffer allocation for efficient binary data processing.
  • Breakpoint Managers - Allows developers to set breakpoints at specific source locations to pause execution and analyze runtime state.
  • Standalone Binary Compilation - Bundles source code and the runtime into independent, standalone binary executables using a build tool.
  • Debugging and Inspection Tools - Provides diagnostic tools for inspecting program state and handling errors during runtime execution.
  • Instruction Stepping Tools - Supports single-instruction stepping for fibers to allow precise observation of state changes during execution.
  • Interactive REPLs - Includes an interactive read-eval-print loop for exploring language features and prototyping in real time.
  • String Buffer Formatting - Ships a mechanism to write formatted strings and values into buffers using template patterns.
  • Bitwise Manipulation Primitives - Provides low-level primitives to read, set, and toggle specific bits within a byte buffer.
  • Mutable Byte Buffers - Provides growable byte buffers to store and modify sequences of bytes representing binary data.
  • Data Layout Mapping - Defines packed structs and arrays to ensure compatible data layout when exchanging complex structures with native code.
  • OS-Level Integrations - Interfaces application logic with OS functions, allowing execution of external programs and access to environment variables.
  • Thread Management - Provides primitives for coordinating execution flows using both native OS threads and green threads.
  • Byte Sequence Handling - Handles raw byte arrays by storing bytes as integer values for efficient manipulation.
  • Byte Stream Parsing - Processes input bytes through a state machine to generate parsed values.
  • CLI Script Execution - Allows executing source files directly from the command line to perform system tasks.
  • Collection Iterators - Implements mechanisms for traversing arrays and tables using callbacks to process individual elements.
  • Destructuring Assignments - Extracts values from data structures within variable definitions and function parameters.
  • Dynamic Code Evaluation - Evaluates strings or pre-compiled bytecode at runtime to enable flexible plugin architectures.
  • Embedded Script Execution - Compiles and runs code provided as strings or byte arrays from within a host program.
  • Execution Flow Control - Implements advanced logic pipelines using threading macros and lazy evaluation for execution flow control.
  • Execution Flow Tracing - Generates formatted stack traces that track the call history of fibers for execution flow analysis.
  • Host-to-Script Function Invocations - Triggers specific functions defined in scripts from a host program using protected calls to handle errors.
  • Fiber Status Inspections - Enables inspection of fiber state, including access to stack frames and child fiber relationships.
  • Pattern Matching - Matches expressions against symbols or arrays to execute conditional logic based on structural shapes.
  • Bytecode Debuggers - Includes a debugger specifically for inspecting and stepping through the execution of the virtual machine's bytecode.
  • String and Numeric Formatting - Provides language-level utilities for concatenating and formatting strings using specifiers and case conversion.
  • Syntax Extensions - Transforms code input into new output before compilation to create custom language constructs.
  • Memory Buffering - Includes capabilities to create and trim buffers to manage memory allocation and capacity.
  • Pointer-Based Memory Access - Allows serializing values into buffers and extracting data directly from raw pointers for native consumption.
  • Message Passing Channels - Provides synchronized communication primitives using FIFO queues to exchange data between concurrent tasks.
  • PEG Text Replacements - Swaps matches of a grammar pattern with replacement strings using the PEG engine.
  • Grammar Optimizations - Optimizes PEG grammar structures during compilation to increase the processing speed of text parsing.
  • Buffer Range Copying - Provides the ability to copy a specific range of bytes from one buffer into another.
  • Input Stream Parsing - Processes byte streams into values with built-in support for checkpoints and error recovery.
  • OTP-Style Supervision Trees - Organizes concurrent tasks into hierarchical supervision trees to monitor health and automate restarts.
  • System Automation Scripts - Provides a lightweight language for automating networking, file system, and OS operations.
  • Fiber Error Propagation - Implements a mechanism for trapping error signals by propagating them up a chain of active fibers.
  • Language Runtimes - Embeddable system scripting language with C interop.

    • Star 历史

    janet-lang/janet 的 Star 历史图表janet-lang/janet 的 Star 历史图表

    Janet 的开源替代方案

    相似的开源项目，按与 Janet 的功能重合度排序。
    • crystal-lang/crystalcrystal-lang 的头像

      crystal-lang/crystal

      20,299在 GitHub 上查看↗

      Crystal is a statically typed, compiled programming language designed for high performance and memory safety. It leverages an LLVM-based compiler to translate source code into optimized machine-executable binaries, while its type-inference-based static analysis enforces strict safety rules during the build process. The language distinguishes itself through a fiber-based concurrent runtime that manages lightweight execution units for asynchronous input and output without blocking the main process. It also features a powerful compile-time macro system that allows for the inspection and transfor

      Crystalcompilercrystalcrystal-language
      在 GitHub 上查看↗20,299
    • gopl-zh/gopl-zh.github.comgopl-zh 的头像

      gopl-zh/gopl-zh.github.com

      4,958在 GitHub 上查看↗

      This project is a Chinese translation of a comprehensive guide to the Go programming language. It serves as a localized educational resource and technical manual designed to provide guidance on language syntax, design, and software development. The resource covers a broad range of Go language education, including the implementation of programming patterns and system design. It includes translated lessons and examples that focus on core language features such as concurrency and the use of interfaces. The content spans various capability areas, including language fundamentals, data modeling, r

      Goprogramming-language
      在 GitHub 上查看↗4,958
    • java-native-access/jnajava-native-access 的头像

      java-native-access/jna

      8,916在 GitHub 上查看↗

      JNA is a foreign function interface and native memory mapper that allows Java applications to call functions in shared native libraries without writing custom JNI wrapper code. It serves as a JNI alternative framework for invoking C functions and mapping native data structures using high-level interfaces. The library distinguishes itself through its ability to translate Java objects and primitives into C-style structs, unions, and pointers for cross-platform memory exchange. On Windows, it provides a dedicated toolkit for interacting with Component Object Model objects using both early and la

      Java
      在 GitHub 上查看↗8,916
    • nim-lang/nimnim-lang 的头像

      nim-lang/Nim

      18,071在 GitHub 上查看↗

      Nim is a statically typed, compiled systems programming language designed for high performance and cross-platform development. It translates high-level source code into C, C++, or JavaScript, allowing developers to produce efficient native binaries or web-compatible scripts from a single codebase. The language emphasizes a clean, indentation-based syntax that simplifies code hierarchy while maintaining the power of a full-featured systems language. What distinguishes Nim is its robust metaprogramming framework, which allows developers to inspect, modify, and generate code structures during th

      Nimcompilerefficienthacktoberfest
      在 GitHub 上查看↗18,071
    查看 Janet 的所有 30 个替代方案→

    常见问题解答

    janet-lang/janet 是做什么的？

    Janet is a Lisp-based dynamic programming language featuring a register-based bytecode virtual machine and an embeddable scripting engine. It functions as a fiber-based concurrency runtime and includes a parsing engine based on Parsing Expression Grammars.

    janet-lang/janet 的主要功能有哪些？

    janet-lang/janet 的主要功能包括：Register-Based Execution, Register-Based VMs, C-Embeddable Runtimes, Register-Based Bytecode, File and Directory Management, PEG-Based Parse Dialects, Custom Text Format Parsing, Macro-Based Code Transformations。

    janet-lang/janet 有哪些开源替代品？

    janet-lang/janet 的开源替代品包括： crystal-lang/crystal — Crystal is a statically typed, compiled programming language designed for high performance and memory safety. It… gopl-zh/gopl-zh.github.com — This project is a Chinese translation of a comprehensive guide to the Go programming language. It serves as a… java-native-access/jna — JNA is a foreign function interface and native memory mapper that allows Java applications to call functions in shared… nim-lang/nim — Nim is a statically typed, compiled systems programming language designed for high performance and cross-platform… mruby/mruby — mruby is a lightweight Ruby interpreter designed to be embedded into C applications. It compiles Ruby source code into… hylang/hy — Hy is a Lisp implementation for Python that allows for writing Lisp syntax which compiles to Python bytecode. It…