This repository is the official implementation of the Elixir programming language. It contains the full compiler chain (Elixir-to-Erlang AST via Erlang source files in `lib/elixir/src/`), the standard library (`lib/elixir/lib/`), the Mix build tool (`lib/mix/`), the ExUnit test framework (`lib/ex_unit/`), the IEx interactive shell (`lib/iex/`), the Logger application (`lib/logger/`), and the EEx template engine (`lib/eex/`). The compiler is self-hosting: Elixir modules are compiled first by a bootstrap Erlang compiler, then later by the compiled Elixir itself. The standard library provides all core data types (String, List, Map, Tuple, etc.), concurrency primitives (Agent, Task, GenServer, Supervisor), I/O (File, IO), and utilities for JSON, URI, Regex, Calendar, etc. Mix is a complete build tool supporting dependency management (Hex, Git, paths), compilation (Elixir, Erlang, Leex, Yecc), testing, profiling, release creation, and archive/escript packaging. Architecturally, the system follows the Erlang/OTP conventions: each component is an OTP application with its own supervision tree, configuration, and lifecycle. The compiler backend is written in Erlang (e.g., `elixir_tokenizer.erl`, `elixir_expand.erl`, `elixir_erl.erl`) and produces Core Erlang for the BEAM VM. The runtime supports distributed process management, hot code swapping, and fault-tolerant supervision. The entire codebase is dual-licensed under Apache 2.0 with the Elixir trademark policy. Key entry points include the `elixir` and `iex` command-line scripts in `bin/`, the Mix CLI (`Mix.CLI`), the Erlang application start (`elixir.erl`), and the REPL server (`IEx.Server`). The system depends only on the Erlang/OTP runtime (OTP 27+), with no other external runtime dependencies. The repository is actively maintained by the Elixir core team with rigorous CI (Linux, macOS, Windows), code quality checks, and license compliance (ORT).
Ergo Framework is a Go implementation of the Erlang/OTP actor model for building concurrent, distributed, and fault-tolerant systems. It provides a complete actor runtime with processes, supervision trees, message passing (local and remote), service discovery, and network transparency. The architecture is library-based: applications import the framework and define actors, supervisors, and applications. Key entry points include `ergo.StartNode()` and the `gen`, `act`, `meta`, and `net` packages. The framework has zero core dependencies and uses a custom binary serialization (EDF) for inter-node communication. It is production-grade, with extensive testing, documentation, and a growing ecosystem of extra libraries (registrars, loggers, meta-processes). The codebase demonstrates high craftsmanship with lock-free data structures, efficient buffer pooling, and well-abstracted patterns. The last commit date appears anomalous (2026-09-04), but the repository is actively maintained with many stars and forks.
Thousand Island is a pure Elixir, OTP-based socket server library inspired by Ranch. It provides a supervision tree (Server → Listener + AcceptorPoolSupervisor → AcceptorSupervisor → Acceptor/DynamicSupervisor → Handler) that handles TCP and SSL connections with configurable concurrency, connection draining, and shutdown semantics. The library exposes a clean `ThousandIsland.Handler` behaviour for application-level protocol logic, and a `ThousandIsland.Socket` abstraction that decorates underlying transport sockets with automatic telemetry instrumentation. It emits rich telemetry spans for listeners, acceptors, and individual connections, supports suspend/resume of connection acceptance, and handles transient network errors and file descriptor exhaustion without crashing the acceptor tree. The code is thoroughly tested and free of external dependencies beyond telemetry, making it both a production-ready server and an exemplar of idiomatic Elixir/OTP patterns.
This repository is a browser extension for generating two-factor authentication (2FA) TOTP and HOTP codes. It allows users to securely store account secrets (optionally encrypted with a passphrase), generate codes for login, and provides features such as autofill into web pages, cloud backups (Dropbox, Google Drive, OneDrive), and synchronization across browsers. The extension is built with TypeScript and Vue 2.x, using Webpack for bundling and Vuex for state management. It supports multiple browsers (Chrome, Firefox, Edge) and manifests for Manifest V3. The architecture consists of a background service worker (for handling events and cloud sync), a popup UI (for displaying codes and managing accounts), an options page (for settings), content scripts (for autofill and QR code scanning), and an import page. Data flows involve storing encrypted account secrets in browser storage, generating OTPs from these secrets, and securely backing up and restoring data via cloud services or encrypted files. External dependencies include browser APIs, cloud service APIs (OAuth), and cryptographic libraries (argon2-browser, crypto-js, node-gost-crypto). The codebase demonstrates good engineering practices with clear separation of concerns, reusable abstractions for encryption and storage, and a modular structure for UI components and cloud backup providers. It includes internationalization support, a security advisor for recommendations, and a test suite (unit and end-to-end). While the project faces some technical debt due to its reliance on Vue 2.x and complex backup integrations, it remains actively maintained and functional.
java-otp is a Java library for generating HOTP (RFC 4226) and TOTP (RFC 6238) one-time passwords. The core functionality resides in two thread-safe classes: HmacOneTimePasswordGenerator for HMAC-based OTPs and TimeBasedOneTimePasswordGenerator for time-based OTPs. The library depends only on the Java standard library, with JUnit and JMH used solely for testing and benchmarking. Entry points include the constructors and methods like generateOneTimePassword and validateOneTimePassword. Data flow involves passing a SecretKey and counter/timestamp to generate or validate OTPs. The architecture is a simple, focused library with no external services or complex dependencies.
This repository contains Stratum, a free and open-source two-factor authentication (2FA) app for Android with Wear OS support. It implements TOTP, HOTP, Steam, Yandex, and mOTP code generation algorithms with configurable parameters. The app features encrypted local backups with AES-GCM/CBC and Argon2id/PBKDF2 key derivation, import from over 15 third-party authenticator apps (Aegis, Bitwarden, KeePass, etc.), QR code scanning via CameraX, and a Material Design 3 UI. The architecture follows a clean layered pattern with a core library (Stratum.Core) containing domain entities, OTP generators, backup converters, and service interfaces, a Droid project for the phone UI, and a Wear OS project. The codebase is well-organized with dependency injection (Autofac), repository pattern for SQLite persistence, and unit tests. It demonstrates strong data engineering skills in reverse-engineering and parsing various backup formats, implementing custom cryptography for Ente Auth, and maintaining a large icon database. The project is actively maintained, targets .NET 10, and has localization in 27+ languages.