This edition of GitHub Trending Today, number 50, features a significant number of projects related to "Jev," a technology that appears to be gaining traction across various applications, from local decision models to code review tools and device control.

Jev Compaction and Summarization

fast-jev-compaction addresses a perceived limitation in standard context compaction methods, where summaries can omit critical details like exact file paths or error messages needed in subsequent interactions. This tool operates by scoring every tool call and its result using Jev. It then selectively deletes entries deemed no longer necessary, ensuring that the original text remains untouched.

Image Editing and Compositing

Compositor is an open-source image editor for macOS. It is built around a compositing workflow, incorporating Photoshop-style shortcuts. Users can combine layers using masks and blend modes, and apply adjustments through editable adjustment layers. The editor preserves the original resolution of layers during resizing, preventing detail loss. Content-aware fill and a clone stamp tool are included for image manipulation and cleanup.

Probabilistic Decision Making with Open Models

SemIf offers a method for reading probabilities directly from option tokens, similar to TypeSafe's Jev. A key distinction is its reliance on downloadable open models, contrasting with services that may have waitlists. Benchmarks indicate a significant speed improvement: when a model is asked to choose from 21 options, the traditional method of generating JSON and parsing it took 5.3 seconds on an RTX 3090. SemIf, by reading typed logits directly, achieved this in approximately 1 second, representing a five-fold increase in speed.

Algorithmic Trading and Market Making

jev-trader is a market maker designed to execute an entire decision process within a single monad block. This approach aims to circumvent issues common in other trading bots, such as extended gas estimation and synchronous sends per order, which can lead to price changes before an order is posted. Jev-trader hardcodes gas limits and static fees, streamlining the execution path. The decision-to-order process reportedly takes about 100 milliseconds, with inference accounting for 80 milliseconds of that time.

Efficient Web Interaction

jev-ultrafast enables web page interaction without generating coordinates or selectors. Unlike agents that screenshot pages, process them with vision models, and then determine click locations, this tool reads the Document Object Model (DOM) directly. It constructs an index table of clickable elements and makes action and target decisions within a single network round trip.

AI-Powered Search and Ranking

jev-search utilizes AI to determine search strategies and rank results without generating a synthesized answer. Users describe their needs, and Jev selects search terms, sources, and time ranges with filter options. Results are presented as links and snippets with visible relevance scores, and duplicate URLs are merged. Self-hosting requires Type-Safe and Search API keys, and each search may incur multiple billable API calls.

Tax Form Classification

Tax.Classifier identifies tax forms on a page-by-page basis, providing labels and confidence scores rather than generated explanations. It extracts text from PDFs and sends it to Type-Safe's Jev model, using form descriptions derived from IRS documents. Low-confidence results can be routed for manual review. The system identifies federal forms in English; scanned pages require Optical Character Recognition (OCR) prior to processing, as they are treated as blank without a text layer.

Local Jev Alternative

Kev is an open-source, local implementation of Type-Safe's Jev that operates entirely on a user's laptop. Built on Qwen 2 5.5B, it processes a document once and answers multiple questions in parallel, returning probabilities instead of generating text. Each question has access to the document but not to other questions. Its local server is compatible with Type-Safe's SDK, allowing for interface reuse.

Nano-Scale Jev for Decision Scoring

NanoJev is a compact Jev replica, featuring 600 million parameters. It scores all possible moves in a single forward pass, rather than generating tokens sequentially. Users provide states, questions, and candidate answers, and batch decisions are processed in one forward pass. The repository includes a training pipeline and browser replays of maze and snake tests.

3D Reconstruction from Video

A bot recon generates 3D reconstructions from video while maintaining a local context of only 12 frames. It estimates geometry and camera movement frame by frame, then integrates these estimates into a global point cloud and trajectory. This method prevents the model's working memory from expanding with video length. Optional loop closure can refine the trajectory upon revisiting a location.

Deterministic Computer Use Agents

Type safe computer use aims to avoid the need for constant screenshotting of frontier models for each interaction. Unlike agents that send screenshots to models like Opus, incurring significant time and cost, this system reads the screen deterministically. It combines OCR, the accessibility tree, and date parsing, only invoking a writing model when text input is required.

Plain Language Conditions for SQL

PG Jev integrates plain language conditions into SQL, enabling filtering of support tickets by sentiment (e.g., "frustration") or classification by department without generating embeddings. It sends batched raw data to Type-Safe's Jev API and caches session-specific answers, allowing threshold adjustments without re-execution. This requires superuser access and PostgreSQL's untrusted Python extension, limiting its use on many managed database hosts.

Smart Home Control Panel

ESP screens transforms an ESP32 touchscreen into a smart home control panel without requiring YAML configuration. This offers an alternative to expensive wall tablets or extensive manual coding for home automation interfaces. The system supports drag-and-drop configuration from Home Assistant, allowing up to 48 tiles across eight pages for controlling lights, climate, blinds, media, and displaying history graphs.

In-Browser Code Agent Operations

A side code mode allows agents to search files, filter results, and batch browser operations within a single JavaScript call. Instead of transmitting entire files or pages, it can return specific paths or extracted fields. Local searches utilize Ripgrep, while browser batches are processed through the native REPL. The efficiency gain stems from reduced tool round trips and smaller output sizes.

AI Code Reviewer Evaluation

Jev review positions AI code reviewers as prompts for investigation rather than definitive bug detectors. Unlike tools that provide confident textual reviews, this system employs bounded judgment calls with explicit thresholds for correctness, security, reliability, and compatibility, avoiding black-box explanations.

Text and JSON to Decision Routing

Lya converts text or JSON into decisions without generating explanatory sentences. Users define questions with choices, binary outcomes, or ordered scores. Its encoder models then return probabilities for routing tickets or content verification. A built-in router selects and loads English, multilingual, or task-focused checkpoints as needed.

Market Making Backtesting

HF Tengine enables frame-by-frame replay of market-making backtests using recorded Binance futures data. Its Rust runner employs HFT backtesting, while the dashboard displays the order book, estimated queue positions, latency, and simulated fills. This allows for detailed inspection of order execution and rejection reasons, rather than just a final score. The simulation excludes market impact and partial fills, and no real orders are placed.

Multi-Agent Project Coordination

Herder projects provides a single coordinator conversation for work distributed across multiple coding agents. After task approval, each worker receives a dedicated work tree and branch with shared instructions and project memory. A sidebar separates completed work from tasks awaiting input, eliminating the need to monitor all conversations.

Coding Agent Progress Monitoring

Forman monitors coding agents during operation, using Jev to assess progress, test coverage, and the need for human intervention. A separate Python policy dictates when to steer the active Codex session, halt a stalled worker, or initiate verification. The worker continues to run during these assessments. The project is presented as an experiment, with Jev's accuracy for this task noted as unproven and requiring calibration.

Transparent Wallet Tracking

Flyon is a wallet tracker that quantifies its inaccuracies. It addresses a common issue where trackers rank users based on lucky airdrops or token transfers, without providing a verifiable hit rate. Flyon records each call to a hash chain ledger before results are finalized, settling against the initial price after the window closes.

Jev-Controlled Game Inputs

Type-safe Mario enables Jev to select controller inputs from structured game data, bypassing the need for screenshots. The program reads emulator memory, converting movement, terrain, and nearby enemies into JSON, with timing calculations handled in code. A live dashboard displays action probabilities and response latency, and logs preserve decisions for analysis.

Procedural Video Generation

Procedural film creates 30-second vertical videos entirely from JavaScript drawing on a canvas and the Web Audio API for sound, without using stock footage or AI-generated clips. Given a topic, an agent writes shots, critiques its own work through multiple review passes, and renders the output as an interactive HTML file and an MP4.

Model Operation Visualization

Titania compiles and runs Qwen 3 0.6B through its own compiler, instruction set, and simulated GPU, allowing users to observe how model operations translate into individual instructions. A live panel displays the executing kernel and disassembly during text generation. Physical GPU implementation, including FPGA and eventual silicon stages, is planned. A warning is issued regarding the chat interface's bash tool, which runs commands without confirmation.

Local Jev-Compatible API

Open Jev SG Lang serves a Jev-compatible API using Kwen, without sending requests to Type-Safe. It scores answer options from first-token probabilities rather than generating explanations and reuses cached context across parallel questions, providing yes/no decisions, choices, and ordered scores through a single interface. The deployment utilizes a B200 GPU on Modal.

PostgreSQL Text Search Testing

Lead allows testing of TIN-compatible text search queries in PostgreSQL without running the production TIN engine. It supports query parsing, scoring, and highlighting, enabling SQL queries to run in development and CI environments. Its index stores no search data, sending each table page back to PostgreSQL for checking, prioritizing correctness over speed. Lead is positioned as a testing substitute, not a production search engine.

Interruptible Voice App Template

Expo GPT Live is a voice app template for iPhones that allows users to interrupt AI replies and maintain background conversations. It integrates GPT Live 1 with web search, a weather tool, and animated personas, keeping OpenAI keys server-side. A native build is required instead of Expo. Users are advised to replace the shared development token with proper user authentication before making the backend public.

AI Code Reviewer Quality Scores

Jev review provides coding agents with separate quality scores instead of written code reviews. Agents submit focused diffs through MCP and receive feedback on dimensions such as correctness and complexity, allowing for score comparison after changes. Jev does not explain the cause of a low score, requiring the agent to investigate and fix the issue. The plugin runs locally, but submitted code is sent to Type-Safe's API for evaluation.

Biomolecular Modeling Optimizations

Anthropic's biomolecular modeling packages optimize inference by integrating with pinned research tools without altering their standard calling interfaces. Modes distinguish between output-preserving optimizations, those allowing minor numerical differences, and those prioritizing reduced GPU memory usage. Each kit reports activated optimizations and rejects unsupported configurations rather than defaulting to fallback options.

Android Action Execution

Mobile Jev translates written goals into Android actions via Mobile Run without requiring an ADB connection. Jev selects an operation and target in a single request, with code verifying target validity before execution. Alive Studio displays the phone, action history, and latency. Text entry replicates the exact wording from the goal, and model confirmation requires verification against the phone's actual state.

Shell Installer Security Checks

Bashka inspects shell installers before execution, flagging patterns such as credential theft, destructive commands, and unverified downloads. It can follow scripts that fetch other scripts and records installed binaries for later review, update, or removal. The system focuses on inspection rather than isolation, as static checks may miss dynamic behavior, and server content can change between review and execution.

Local Language Model Execution on Apple Silicon

Splash runs language models locally on Apple silicon using tailored kernels and draft models. Drafts propose token blocks that the main model checks in parallel, while startup calculates a memory budget for the Mac. It exposes OpenAI and Anthropic-compatible APIs for existing clients. This approach restricts the use of ordinary MLX or Transformers checkpoints.

Direct Answer Selection

Simple Jev is designed for scenarios where a model needs to select an answer rather than generate an essay. It reads logits directly, returning choice scores and truth judgments as JSON without requiring parsing. It caches the shared prefix across questions, reportedly reducing token usage from 4,200 to 1,200 for four questions on a single document.

Local Decision Interface

Local Jev enables applications using Type-Safe's decision interface to utilize a local language model through a standard chat endpoint. It translates questions into classification prompts, validates returned JSON, and calculates choices and scores in code. The probabilities are model-generated numbers, not values read directly from internal logits.

Instruction-Based Code Checks

Abide transforms project instructions into checks that run after coding agent edits and at the end of each turn. It sends rules and changed code to Jev, then prompts the agent to repair likely violations, including judgment calls beyond a linter's scope. Each verdict links back to the original instruction. Edits proceed unchecked without a network connection or key.

Plain English Rule-Based Code Scanning

Perch checks code against plain English rules using Jev, allowing requirements such as keeping environment variable reads out of individual methods to be expressed. Rules can be scoped to files, with selectable checks and YAML-defined thresholds. Scans produce ranked findings with line numbers and confidence scores, and issues can be rechecked after fixes.