awesome-repositories.com
Blog
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
ProjetÀ proposNotre méthodologiePresseServeur MCP
Mentions légalesConfidentialitéConditions d'utilisation
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·

11 dépôts

Awesome GitHub RepositoriesSingle-Threaded Execution Models

Architectural patterns where code execution is restricted to a single main thread to eliminate concurrency locks.

Distinguishing note: Candidates focus on renderers or synchronized multi-threading; this is a general single-threaded runtime model.

Explore 11 awesome GitHub repositories matching software engineering & architecture · Single-Threaded Execution Models. Refine with filters or upvote what's useful.

Awesome Single-Threaded Execution Models 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.
  • nodejs/node-v0.x-archiveN

    nodejs/node-v0.x-archive

    34,301Voir sur GitHub↗

    This project is a read-only archive of historical versions and development records for an early V8-based JavaScript runtime. It functions as an event-driven server-side environment that executes JavaScript code outside of a web browser. The archive preserves the identity of the runtime as an evented I/O framework, designed for handling asynchronous network and file system operations through a non-blocking event loop. It provides access to read-only records of old issues and pull requests to track the evolution of these legacy versions. The project covers the domain of server-side execution a

    Executes JavaScript on a single main thread to avoid complex locking and shared state concurrency.

    Voir sur GitHub↗34,301
  • nikopueringer/corridorkeyAvatar de nikopueringer

    nikopueringer/CorridorKey

    13,940Voir sur GitHub↗

    Perfect Green Screen Keys

    Runs the entire keying pipeline on a single thread per clip for simplicity and deterministic output.

    Python
    Voir sur GitHub↗13,940
  • huangzworks/redis-3.0-annotatedAvatar de huangzworks

    huangzworks/redis-3.0-annotated

    10,172Voir sur GitHub↗

    This project provides a version of the Redis 3.0 codebase featuring detailed technical commentary and annotations. It serves as a technical resource for studying the internal design and implementation of an in-memory key-value store and the architecture of a networked NoSQL database. The documentation focuses on the implementation of the Redis Sentinel system, covering the mechanisms used for monitoring instance health, managing automatic failover, and notifying clients of primary node changes. The project covers broader architectural areas including in-memory data storage, high availability

    Employs a single-threaded execution model to process requests sequentially and eliminate locking overhead.

    C
    Voir sur GitHub↗10,172
  • actix/actixAvatar de actix

    actix/actix

    9,223Voir sur GitHub↗

    Actix is a Rust actor framework and concurrent programming toolkit designed for building applications that manage state through an asynchronous messaging system. It provides a model where independent actors serve as autonomous units of state and logic, communicating via strongly typed messages sent to unique addresses. The framework distinguishes itself by isolating state within these actors, allowing internal data to be mutated safely during message handling without the use of locks or mutexes. It employs an asynchronous mailbox system to buffer incoming requests and uses supervision strateg

    Ensures thread-safe state mutation by processing messages sequentially within a single-threaded actor execution model.

    Rustactixactoractor-model
    Voir sur GitHub↗9,223
  • phuocng/html-domAvatar de phuocng

    phuocng/html-dom

    6,524Voir sur GitHub↗

    This is a vanilla JavaScript DOM manipulation library that provides a collection of native methods for selecting, creating, and modifying HTML DOM elements without any framework dependencies. It operates directly on the live DOM tree using imperative JavaScript calls, wrapping standard browser DOM APIs into reusable utility functions. The library covers the full spectrum of DOM operations including element selection, creation, removal, content and attribute management, event handling, style and class manipulation, and DOM traversal. It includes approaches for cross-browser DOM compatibility,

    Runs all DOM manipulations synchronously on the main browser thread without async scheduling or batching.

    MDXdocument-object-modeldomdom-api
    Voir sur GitHub↗6,524
  • lite-xl/lite-xlAvatar de lite-xl

    lite-xl/lite-xl

    6,222Voir sur GitHub↗

    Lite XL is a lightweight, cross-platform text editor built around a minimal C core that embeds a Lua interpreter, allowing the entire editor interface and functionality to be scripted and customized through Lua. It draws text and UI elements directly to a pixel buffer using a single-threaded event loop, bypassing heavyweight widget toolkits to keep the editor fast and responsive even on low-resource hardware. The editor distinguishes itself through its Lua-based plugin architecture and file-based configuration system, where settings, keybindings, and plugin metadata are stored as plain Lua fi

    Processes input, rendering, and plugin execution sequentially on one thread, avoiding concurrency complexity and keeping resource usage low.

    Luaccodecode-editor
    Voir sur GitHub↗6,222
  • mimecorg/vuidoAvatar de mimecorg

    mimecorg/vuido

    6,062Voir sur GitHub↗

    Vuido is a framework for building native desktop applications for Windows, macOS, and Linux using Vue.js components, without requiring Electron or Chromium. It maps Vue components directly to native widgets from the libui library, creating lightweight applications that run on a single-threaded event loop and compile templates at build time for optimized runtime performance. The framework provides a complete Vue.js component-to-native bridge, enabling two-way data binding via v-model, component-based window composition, and platform-specific package generation for distributing executables. It

    Runs the application's main loop on a single thread, processing user input and UI updates synchronously.

    JavaScriptdesktoplibuivue
    Voir sur GitHub↗6,062
  • doctrine/event-managerAvatar de doctrine

    doctrine/event-manager

    6,047Voir sur GitHub↗

    Doctrine Event Manager is a PHP library that implements a publish-subscribe pattern for decoupled application communication. It provides a simple event bus that dispatches named events to registered listeners, enabling components to communicate without direct method calls and promoting loose coupling and extensibility in PHP projects. The library manages listener callbacks in a central registry keyed by exact event name strings for fast lookup, and invokes listeners in priority sequence for controlled reaction order during event dispatch. It maintains no internal state between dispatches, rel

    Invokes all listeners sequentially on the same thread, ensuring predictable and deterministic execution.

    PHPeventeventmanager
    Voir sur GitHub↗6,047
  • reactor/reactor-coreAvatar de reactor

    reactor/reactor-core

    5,224Voir sur GitHub↗

    Reactor Core est une boîte à outils de programmation réactive et une fondation non bloquante pour composer des pipelines de données asynchrones sur la JVM. Il sert de framework de traitement de flux asynchrone et de système de gestion de contre-pression (backpressure), permettant aux développeurs de transformer, filtrer et combiner des séquences d'événements tout en régulant le flux de données entre les producteurs et les consommateurs pour éviter l'épuisement des ressources. La bibliothèque se différencie par un système sophistiqué de planification de la concurrence et un contrôle de flux basé sur la demande. Elle découple le traitement des signaux de threads spécifiques en utilisant un registre de planificateur et fournit des mécanismes pour la propagation de métadonnées immuables sensibles au contexte à travers les frontières asynchrones. Elle dispose également d'outils spécialisés pour la capture de traces au moment de l'assemblage et la planification en temps virtuel pour faciliter le test des opérateurs basés sur le temps. Le projet couvre un large éventail de capacités, incluant le traitement fonctionnel de données pour l'agrégation et le fenêtrage de séquences, une variété de stratégies de récupération d'erreurs comme les tentatives avec backoff exponentiel, et des utilitaires pour faire le pont entre les API de rappel (callback) héritées ou synchrones et les flux réactifs. Elle fournit en outre une instrumentation pour la surveillance des pipelines et une suite d'outils de test pour vérifier les séquences de signaux.

    Converts asynchronous events from a single producing thread into a reactive stream while managing backpressure.

    Javaasynchronousflowflux
    Voir sur GitHub↗5,224
  • not-fl3/macroquadAvatar de not-fl3

    not-fl3/macroquad

    4,500Voir sur GitHub↗

    Macroquad est un moteur de jeu Rust et une bibliothèque graphique 2D conçue pour développer des jeux multiplateformes et des applications graphiques. Il fonctionne comme un moteur de rendu qui permet le déploiement d'une base de code unique vers des cibles de bureau, mobiles et web. Le moteur utilise un modèle de rendu en mode immédiat, qui permet la création d'interfaces utilisateur et de mondes de jeu qui se rendent en un seul passage au sein de la boucle d'application principale. Cette approche est associée à un rendu 2D accéléré par matériel et à un regroupement automatique des appels de dessin pour optimiser l'affichage de la géométrie sur différents appareils matériels. Le framework fournit un pipeline de build unifié pour compiler les applications en binaires natifs ou en WebAssembly pour un déploiement basé sur le web. Il inclut une couche d'abstraction matérielle pour mapper les appels génériques d'entrée et de graphiques vers les API système spécifiques à la plateforme.

    Employs a single-threaded execution loop to simplify game logic and rendering synchronization.

    Rust
    Voir sur GitHub↗4,500
  • eventmachine/eventmachineAvatar de eventmachine

    eventmachine/eventmachine

    4,283Voir sur GitHub↗

    EventMachine est un framework réseau basé sur le pattern reactor pour Ruby, fournissant une bibliothèque d'E/S asynchrones pour les opérations réseau et fichiers non bloquantes. Il sert de framework de serveur réseau pour construire des serveurs et clients TCP et UDP scalables traitant de multiples requêtes simultanées. Le framework implémente un modèle de concurrence qui distribue les événements réseau aux gestionnaires enregistrés via une boucle d'événements monothread. Cette approche permet de gérer des connexions réseau à haute concurrence sans la surcharge de la programmation multithread. La bibliothèque couvre le développement de serveurs pilotés par les événements, de clients réseau asynchrones et d'implémentations de proxy réseau. Elle offre également des capacités de surveillance de fichiers et de réseaux pour déclencher des actions lors d'événements spécifiques.

    Handles thousands of simultaneous connections on one thread to eliminate locking and context switching overhead.

    Ruby
    Voir sur GitHub↗4,283
  1. Home
  2. Software Engineering & Architecture
  3. Single-Threaded Execution Models

Explorer les sous-tags

  • Single-Threaded Event BridgingBridging asynchronous events from a single thread into a reactive stream with integrated backpressure management. **Distinct from Single-Threaded Execution Models:** Focuses on the bridging mechanism from a single thread to a stream, rather than just a general single-threaded execution model.
  • Synchronous Single-Threaded InvocationsInvoking all listeners sequentially on the same thread for predictable and deterministic execution. **Distinct from Single-Threaded Execution Models:** Distinct from Single-Threaded Execution Models: focuses on synchronous invocation of listeners rather than general single-threaded runtime.