awesome-repositories.com
Blog
MCP
awesome-repositories.com

Découvrez les meilleurs dépôts open-source grâce à notre recherche par IA.

ExplorerRecherches sélectionnéesAlternatives open sourceLogiciels auto-hébergésBlogPlan du site
ProjetServeur MCPÀ proposNotre méthodologiePresse
Mentions légalesConfidentialitéConditions d'utilisation
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·

6 dépôts

Awesome GitHub RepositoriesHigh-Performance Expression Evaluators

Systems that use bytecode compilation and virtual machines to execute dynamic logic with minimal overhead.

Distinct from High Performance Task Execution: Existing candidates focus on build scripts, game tasks, or web rendering, whereas this is for general-purpose expression evaluation in application logic.

Explore 6 awesome GitHub repositories matching programming languages & runtimes · High-Performance Expression Evaluators. Refine with filters or upvote what's useful.

Awesome High-Performance Expression Evaluators GitHub Repositories

Trouvez les meilleurs dépôts grâce à l'IA.Nous recherchons les dépôts les plus pertinents grâce à l'IA.
  • expr-lang/exprAvatar de expr-lang

    expr-lang/expr

    7,906Voir sur GitHub↗

    Expr is a statically typed expression engine and domain-specific language for parsing and evaluating dynamic logic strings within Go applications. It functions as a bytecode expression evaluator that executes compiled logic with guaranteed termination and memory safety. The engine utilizes a specialized compiler and virtual machine to achieve high-performance execution. It employs static type validation during the compilation phase to ensure operand compatibility and prevent runtime crashes. The project provides a data transformation engine capable of mapping, filtering, and aggregating coll

    Running complex logic via a bytecode compiler and virtual machine to achieve faster evaluation than standard interpreters.

    Gobytecodeconfiguration-languageengine
    Voir sur GitHub↗7,906
  • vespa-engine/vespaAvatar de vespa-engine

    vespa-engine/vespa

    6,961Voir sur GitHub↗

    Vespa is a distributed search engine, vector database, and machine learning ranking engine. It serves as an AI search platform designed to handle large-scale document indexing and complex query processing across a cluster of nodes, combining keyword retrieval with high-dimensional embedding storage for semantic similarity search. The platform distinguishes itself by integrating machine learning models directly into the search pipeline to perform real-time inference and ranking. It converts these models into ranking expressions to score and order results based on relevance, while providing a s

    Executes high-performance ranking and scoring logic by converting ML models and expressions into efficient evaluation code.

    Java
    Voir sur GitHub↗6,961
  • killme2008/aviatorscriptAvatar de killme2008

    killme2008/aviatorscript

    5,216Voir sur GitHub↗

    Aviatorscript est un langage de script haute performance et un moteur d'évaluation d'expressions conçu pour l'intégration au sein d'applications Java. Il permet l'exécution dynamique de formules mathématiques et logiques en compilant les instructions de script directement en bytecode Java à l'exécution. Le moteur se distingue en transformant la logique dynamique en instructions lisibles par machine, permettant des vitesses d'exécution proches du natif. Il inclut un mécanisme de mise en cache intégré qui stocke le bytecode compilé pour éliminer l'analyse redondante et la surcharge de compilation lors de l'exécution répétée de formules. Cette bibliothèque prend en charge le traitement de règles complexes et la personnalisation de la logique à l'exécution, fournissant un pont qui mappe les appels de fonction au niveau du script aux méthodes du langage hôte. Elle gère les types de variables dynamiquement, permettant une exécution de script flexible sans nécessiter de déclarations explicites ou d'étapes de compilation statique.

    Transforms dynamic formulas into executable machine instructions at runtime to achieve high-performance calculation speeds.

    Javaaviatorscriptexpression-evaluatorjava
    Voir sur GitHub↗5,216
  • mapstermapper/mapsterAvatar de MapsterMapper

    MapsterMapper/Mapster

    5,127Voir sur GitHub↗

    Mapster est un moteur de mapping objet-vers-objet .NET haute performance utilisé pour transformer des données entre différents modèles d'objets. Il fonctionne comme un outil de transfert de données typé et un outil de projection de requêtes LINQ pour déplacer des données entre la logique interne et les structures de données externes. Le moteur utilise des expressions de mapping compilées et du code machine pour réduire la surcharge lors de la conversion d'objets. Il permet spécifiquement de projeter des sources de données requêtables directement dans des types de destination pour optimiser la récupération en base de données. L'ensemble d'outils couvre la génération d'objets de transfert de données, la transformation de données immuables et la projection de résultats de requêtes. Il inclut des capacités pour mapper des collections immuables, préserver les références d'objets et injecter des paramètres d'exécution dans le processus de transformation.

    Utilizes compiled mapping expressions and machine code to maximize throughput during object conversions.

    C#
    Voir sur GitHub↗5,127
  • google/cel-goAvatar de google

    google/cel-go

    2,875Voir sur GitHub↗

    cel-go is a Go implementation of the Common Expression Language, providing a type-safe engine for the evaluation of non-Turing complete, side-effect-free expressions. It functions as an embedded expression engine that converts human-readable strings into type-checked abstract syntax trees to ensure safe execution. The system utilizes a compile-once evaluate-many model, parsing and validating expressions into cached programs for repeated execution across different datasets. It further distinguishes itself as a partial state evaluator, using commutative logic to compute results and return resid

    Parses expressions into cached programs for repeated high-performance execution across different input datasets.

    Gocelexpressionexpression-evaluator
    Voir sur GitHub↗2,875
  • happykit/flagsAvatar de happykit

    happykit/flags

    1,040Voir sur GitHub↗

    Flags is a feature management platform designed to synchronize application configurations and feature toggles across server and client environments. It provides the infrastructure to evaluate and distribute settings in real-time, allowing for the control of application behavior without requiring code redeployments. The system is built to support isomorphic flag resolution, ensuring that evaluation logic remains consistent during transitions between server-side and client-side rendering. By utilizing server-side state hydration and local fallback caching, the platform prevents visual layout sh

    Optimizes flag evaluation performance by utilizing local caching and infrastructure-level lookups to minimize latency.

    TypeScriptfeature-flagsfeature-togglesnextjs
    Voir sur GitHub↗1,040
  1. Home
  2. Programming Languages & Runtimes
  3. High-Performance Expression Evaluators

Explorer les sous-tags

  • C-Based EvaluationHigh-performance evaluation of expressions by converting them into compiled C code. **Distinct from High-Performance Expression Evaluators:** Distinct from general expression evaluators by specifically utilizing C-code generation for maximum performance.
  • Flag Evaluation EnginesHigh-performance components for executing flag logic with minimal latency. **Distinct from High-Performance Expression Evaluators:** Distinct from High-Performance Expression Evaluators: focuses specifically on the evaluation of feature flag rules rather than general-purpose expression bytecode.
  • Object Transformation CompilersSystems that compile object mapping logic into executable code to eliminate reflection overhead. **Distinct from High-Performance Expression Evaluators:** Focuses on compiling mapping expressions for object-to-object conversion, rather than general-purpose logic evaluation.
  • Program Caching StrategiesCaching parsed and type-checked expression trees as reusable programs to maximize execution speed. **Distinct from High-Performance Expression Evaluators:** Distinct from High-Performance Expression Evaluators: specifically addresses the compile-once evaluate-many caching model.