AI Trending

Project directory

Projects

Open-source AI projects tracked by the leaderboard, ordered by GitHub stars.

TypeScript 6 stars

shivanshgupta365/RiskDelta-AI

Multi-tenant AI runtime control plane for risk scoring, policy enforcement, and evidence-preserving agent operations.

Overview: RiskDelta is a multi-tenant AI runtime control plane designed for production LLM systems, AI agents, copilots, and enterprise AI applications. It scores risky model behavior, enforces policies, blocks unsafe tool calls, requires human approval, preserves evidence, and creates traceability across users, models, agents, and tools. Key features: - Risk scoring - Policy enforcement - Runtime guardrails - Human approvals - Audit trails - TraceVault evidence preservation Tech stack: TypeScript Why it matters: RiskDelta provides a comprehensive solution for the execution layer of AI, ensuring secure, auditable, and controllable AI systems.
Zig 6 stars

svayatta/loom

Distributed expert cache for large MoE inference: swarm-shared GGUF weights, node-local compute, gossip discovery, OpenAI-compatible API. One static Zig binary with Metal/Vulkan backends.

### Overview: Loom is a distributed expert cache system designed for large models like Qwen, enabling efficient inference on ordinary machines. It uses a static Zig binary with Metal/Vulkan backends, serving an OpenAI-compatible API. ### Key features: - **Distributed Expert Cache**: Stores only the necessary weights, reducing the need for large model checkpoints. - **Local Compute**: All computation stays local to each node, reducing network traffic. - **Gossip Discovery**: Nodes discover each other using a gossip protocol. - **Weight Repair**: Repairs weights in case of network churn. - **Merkle Manifest**: Verifies weights against a Merkle manifest for security. ### Tech stack: Zig 0.16.0 with Metal/Vulkan backends. ### Why it matters: Loom simplifies the management of large models, making them accessible and efficient on standard hardware. It reduces the need for expensive GPU resources and minimizes network traffic, making it ideal for distributed computing environments. ### Repository: svayatta/loom ### GitHub stars: 6 ### GitHub description: Distributed expert cache for large MoE inference: swarm-shared GGUF weights, node-local compute, gossip discovery, OpenAI-compatible API. One static Zig binary with Metal/Vulkan backends.
Jupyter Notebook 6 stars

tatwan/handson-genai

This is a a hands-on course teaching GenAI Foundations including Deep Learning, NLP, LLMs, Prompt Engineering, Fine Tuning, RAG, and Optimization (distillation, pruning, and quantization).

### Overview: This intensive three-day training course combines theory with extensive hands-on practice to teach participants how to build production-ready generative AI applications using state-of-the-art models and techniques. ### Key features: - **Hands-on Labs:** 32 hands-on notebooks covering all aspects of AI foundations, deep learning, natural language processing, large language models, prompt engineering, fine-tuning, retrieval augmented generation, and optimization. - **Modern Topics:** Includes modern topics such as diffusion models, multimodal AI, retrieval augmented generation (RAG), AI agents, and production optimization. - **Practical Applications:** Designed for developers, data engineers/analysts, and tech product owners, focusing on practical skills for building AI applications. ### Tech stack: Jupyter Notebook ### Why it matters: This course equips participants with the skills and knowledge necessary to build and deploy production-ready generative AI applications, making them valuable assets in the tech industry.
Rust 6 stars

tbogdala/sentient_core

A terminal style user interface to chat with AI characters using llama LLMs for locally processed AI.

### Overview: Sentient Core is a terminal-based interface designed for interacting with AI characters using LLMs, aiming to provide a locally processed AI experience. ### Key Features: - GGUF Llama models or any model supported by Llama.cpp. - GPU layer offloading for accelerated local text generation. - Optionally use koboldcpp as a backend for text generation. - Streaming-mode for text inference. ### Tech Stack: Rust ### Why it Matters: Sentient Core offers a unique and user-friendly interface for interacting with AI characters, leveraging advanced LLMs for a locally processed experience.
Python 6 stars

techsaurabh-394/ai-engineer-roadmap

Free AI Engineer roadmap: 113 beginner-friendly topics on RAG, LLMs, AI agents, MCP, fine-tuning and production AI. Runnable offline Python, diagrams, interview questions.

Overview: This is a comprehensive AI Engineer roadmap that covers 113 beginner-friendly topics on RAG, LLMs, AI agents, frameworks, and production AI. It includes runnable Python code, diagrams, and interview questions. Key features: - 113 topics - Python 3.10 or newer - Diagrams and code examples - 3 interview questions per topic - Structured learning path Tech stack: Python Why it matters: This roadmap provides a clear, structured approach for beginners and developers moving into AI engineering, ensuring they can understand and apply these concepts effectively.
C# 6 stars

thijse/LLMJson

Library to facilitate sharing json models with LLMs in C-sharp

Overview: LLMJson is a C# library designed to facilitate the sharing and interpretation of JSON models with Large Language Models (LLMs). It aims to address the limitations of LLMs in generating well-formed JSON, making it easier for developers to integrate LLMs into their applications. Key features: - Serializes and generates descriptions for JSON values. - Handles parsing of up to 2GB of JSON files. - Supports parsing of abstract classes and interfaces. - Provides robust handling of field values, including non-standard formats. - Offers special property wrappers for runtime manipulation of fields. Tech stack: C# Why it matters: LLMJson simplifies the process of integrating LLMs into applications by providing a way to serialize and interpret JSON models, making it easier for developers to leverage the capabilities of LLMs in their projects.
Python 6 stars

tsotchke/tensorcore

CUDA-equivalent tensor-core acceleration for Apple Silicon. C-ABI kernel library wrapping simdgroup_matrix (M1+) and mpp::tensor_ops (M5+): GEMM, FlashAttention, Conv2D, Q4_0/Q8_0 quantized inference, GGUF reader, full transformer training kernels. One binary, M1 → M5.

Overview: `tensorcore` is a software layer designed to bridge the gap between Metal GPUs and traditional CUDA hardware, enabling efficient tensor operations on Apple Silicon. It provides a CUDA-equivalent library that simplifies the development of AI models. Key features: - `tc_gemm` for matrix operations - `tc_attention_*` for attention mechanisms - `tc_conv2d_*` for convolutional layers - `tc_rmsnorm / RoPE` for normalization - `tc_swiglu / softmax / AdamW` for activation functions - `tc_gemv_quantized` for quantized inference - `tc_gguf_*` for GGUF reader - `tc_allreduce / broadcast / allgather` for communication primitives Tech stack: Python Why it matters: By providing a seamless integration between Metal GPUs and traditional CUDA hardware, `tensorcore` enables teams to leverage the full potential of Apple Silicon for training large AI models, reducing the need for expensive hardware upgrades and improving overall efficiency. Repository: tsotchke/tensorcore GitHub stars: 6 GitHub description: CUDA-equivalent tensor-core acceleration for Apple Silicon. C-ABI kernel library wrapping simdgroup_matrix (M1+) and mpp::tensor_ops (M5+): GEMM, FlashAttention, Conv2D, Q4_0/Q8_0 quantized inference, GGUF reader, full transformer training kernels. One binary, M1 → M5.
Jupyter Notebook 6 stars

ttop32/jpn_vert_traineddata

tesseract jpn_vert traineddata fintune

Overview: This project fine-tunes the Tesseract Japanese vertical (jpn_vert) model with 16 types of Japanese fonts to achieve a BCER (Best Character Error Rate) of 1% while improving text segmentation performance. Key features: - Fine-tuned Tesseract jpn_vert model with 16 Japanese fonts - Achieved BCER of 1% after fine-tuning - Improved text segmentation performance Tech stack: Jupyter Notebook Why it matters: This fine-tuning process enhances the accuracy and segmentation capabilities of the Tesseract Japanese vertical model, making it more suitable for Japanese vertical text recognition tasks.
Python 6 stars

vikrant-project/vikrant-OBLITERATUS

⚡ Advanced AI iteration framework featuring an 8-stage pipeline, automated fine-tuning, voice interaction, and security scanning.

Overview: vikrant-OBLITERATUS is an advanced AI iteration framework that features an 8-stage pipeline, automated fine-tuning, voice interaction, and security scanning. Key features: - Auto Fine-Tuning: Post-abliteration LoRA adapter recovers 89% of lost coherence. - Voice Pipeline: Transcribes audio input for abliteration and synthesizes output. - Real-Time Sessions: Live WebSocket sessions for collaborative research. - Dark Web Scanner: Cryptographic fingerprinting to detect adversarially modified models. Tech stack: Python. Why it matters: This framework provides a comprehensive solution for removing refusal mechanisms from large language models, ensuring production-grade model liberation with enhanced capabilities and security measures. Repository: vikrant-project/vikrant-OBLITERATUS Primary language: Python GitHub stars: 6 GitHub description: ⚡ Advanced AI iteration framework featuring an 8-stage pipeline, automated fine-tuning, voice interaction, and security scanning.
Python 6 stars

vishvaRam/Fine-Tuning-Siglip2-Vit-Model

This repository offers tools and guidance for fine-tuning the Siglip2 Vision Transformer (ViT) model. It includes scripts and best practices to adapt the model for custom datasets and tasks. Designed for researchers and developers, it ensures efficient fine-tuning and optimal performance for vision-based applicatio

Overview: This repository provides tools and guidance for fine-tuning the Siglip2 Vision Transformer (ViT) model, including scripts and best practices for adapting the model to custom datasets and tasks. It is designed for researchers and developers aiming for efficient fine-tuning and optimal performance in vision-based applications. Key features: - Fine-tuning scripts for ViT models - Adaptation of ViT models for custom datasets - Best practices for efficient fine-tuning Tech stack: Python Why it matters: This repository offers practical solutions for researchers and developers looking to enhance the performance of vision-based applications by fine-tuning the Siglip2 ViT model.
TypeScript 6 stars

waldekmastykarz/atifact

Turn HAR files, Claude Code, Copilot CLI, and Codex CLI logs into standardized ATIF v1.8 trajectory JSON — ready for debugging, visualization, fine-tuning, and RL pipelines.

Overview: atifact is a command-line tool that converts various agent logs into standardized ATIF trajectories, making it easier to debug, visualize, and fine-tune AI agent models. Key features: - Converts HAR files - Converts Claude Code logs - Converts Copilot CLI logs - Converts Codex CLI logs - Automatically detects and converts Vally Trajectory objects Tech stack: TypeScript Why it matters: atifact simplifies the process of extracting and standardizing agent logs, making it easier to work with and analyze AI agent trajectories for debugging, visualization, and fine-tuning purposes. Repository: waldekmastykarz/atifact Primary language: TypeScript GitHub stars: 6 GitHub description: Turn HAR files, Claude Code, Copilot CLI, and Codex CLI logs into standardized ATIF v1.8 trajectory JSON — ready for debugging, visualization, fine-tuning, and RL pipelines.
Python 6 stars

zamax14/Laya-Finetune

Fine-tune Laya, the open System One decision model, for any typed-decision task: synthetic data, RLCD, calibration and long context.

### Overview: Laya Finetune is a powerful tool for fine-tuning Laya, the open System One decision model, to perform any typed-decision task. It simplifies the process by providing a simple CLI and Python API, allowing users to quickly and efficiently fine-tune Laya for their specific needs. ### Key Features: - **Generate:** The answers are chosen first, and an LLM writes a text that has them. - **Verify:** A second LLM is used to verify the labels, ensuring accuracy. - **Train:** The model is trained with RLCD and calibrated to provide confidence scores. - **Calibrate:** The confidence is calibrated to improve accuracy. - **Grow Context:** The context is expanded up to 32k tokens, making it suitable for long decision-making tasks. ### Tech Stack: - **Python:** The primary programming language used for development and fine-tuning. ### Why It Matters: Laya Finetune simplifies the process of fine-tuning Laya, making it accessible to developers who want to leverage the decision model for their specific tasks. By providing a simple CLI and Python API, it reduces the learning curve and speeds up the fine-tuning process, making it an ideal solution for developers looking to improve the performance of their decision models.
Shell 6 stars

zeeb0tt/runpod-llm

Runpod-LLM provides ready-to-use container scripts for running large language models (LLMs) easily on RunPod.

Overview: Runpod-LLM provides a simple and efficient way to deploy large language models (LLMs) on RunPod, making it easy to use without needing deep knowledge of containerization or backend selection. Key features: - Easy Setup: Quick deployment using Docker images. - Flexible: Supports both Ollama and llama.cpp backends. - RunPod Modes: Choose between serverless and POD modes. Tech stack: Shell Why it matters: This tool simplifies the process of integrating LLMs into production environments, making it accessible for developers without extensive technical expertise.
Rust 6 stars

zenlm/engine

High-performance inference engine — Rust/MLX/GGUF

Overview: A high-performance inference engine built with Rust, MLX, and GGUF for efficient model deployment. Key features: - High-performance inference - Rust-based engine - Supports MLX and GGUF formats Tech stack: Rust Why it matters: This engine is optimized for fast model deployment, making it ideal for applications requiring real-time inference capabilities.
JavaScript 5 stars

AI-First-Community/Bodhi

An open, interactive knowledge graph of modern AI — 123 concepts from tokens & attention to LoRA, DPO, reasoning models, and agents, with typed connections. Fully offline, zero dependencies. Built on the Open Knowledge Format.

### Overview: Bodhi Map is an open, interactive knowledge graph of modern AI concepts, providing a comprehensive overview of 128 concepts from tokens & attention to LoRA, DPO, reasoning models, and agents. It is fully offline and zero dependencies, built on the Open Knowledge Format, making it accessible and easy to navigate. ### Key Features: - **Concepts Overview**: 128 concepts categorized into 12 clusters. - **Interactive Graph**: Nodes represent techniques, and edges represent connections and relationships. - **Type-Specific Edges**: Edges are labeled with types to indicate the nature of the connection. - **Fully Offline**: No internet required, perfect for offline use. - **Zero Dependencies**: No external libraries needed, making it lightweight and easy to install. ### Tech Stack: - JavaScript ### Why It Matters: - **Connections Between Techniques**: Understand how different AI techniques build upon each other and when to use them. - **Navigable Landscape**: A single, interactive graph that shows the entire landscape of modern AI. - **Self-Learning Tool**: Ideal for anyone learning or building with modern AI, including students, engineers, and educators. - **MIT-Licensed**: Open-source, MIT-licensed, ensuring freedom to use, modify, and share the project. ### Repository: - **AI-First-Community/Bodhi** - **Primary Language**: JavaScript - **GitHub Stars**: 5 ### See It In Action: - **Live App**: Explore concepts and their connections, search or click any node to see its relationships
Python 5 stars

AbdelStark/exitreceipt

Did the agent actually finish? Inspectable GLiNER2.5-Decide fine-tuning on task completion and evidence spans.

### Overview: ExitReceipt is a tool designed to evaluate the completeness of an agent's actions by comparing them against the evidence left behind. It uses GLiNER2.5-Decide for a yes/no decision and candidate evidence spans, fine-tuning a LoRA adapter to improve accuracy and detect missed completions. ### Key Features: - **GLiNER2.5-Decide Integration**: Uses GLiNER2.5-Decide for decision-making and evidence span analysis. - **LoRA Adapter Fine-Tuning**: The selected LoRA adapter is fine-tuned to improve accuracy and detect missed completions. - **Pairwise Comparison**: Evaluates the correctness of the agent's actions against the evidence left behind. - **External Test**: The tool is tested on 590 paired WorkBench tasks, including 158 runs across 79 tasks and 10 templates unseen during training. ### Tech Stack: - **Python**: The primary language used for development and evaluation. ### Why It Matters: ExitReceipt provides a way to objectively assess whether an agent has completed its task correctly by comparing its actions against the evidence it left behind. This is particularly useful in scenarios where the agent's output is not immediately clear, such as in complex decision-making processes. The tool's ability to detect missed completions and false positives can help in identifying and improving the agent's performance.
Python 5 stars

Ahghaffari/redditpersona

RedditPersona: Modular pipeline for community-conditioned LLM adaptation from Reddit

### Overview: RedditPersona is a modular pipeline designed for community-conditioned LLM adaptation from Reddit, focusing on training parameter-efficient LoRA adapters for different community grouping strategies. It collects Reddit data, builds structured user profiles, partitions users into five strategies, and evaluates the performance of each strategy on generation quality and persona fidelity metrics. ### Key features: - **Data Collection**: Collects Reddit data using AsyncPRAW. - **User Profiling**: Builds structured profiles and text corpora per active user. - **Community Grouping**: Orchestrates five interchangeable strategies for community partitioning. - **LLM Adaptation**: Fine-tunes a parameter-efficient LoRA adapter per strategy using QLoRA. - **Evaluation Metrics**: Evaluates each adapter on fluency, diversity, semantic fidelity, distributional alignment, and community identifiability. ### Tech stack: Python ### Why it matters: RedditPersona provides a systematic approach to community-conditioned LLM adaptation, ensuring that the model's output aligns with the characteristics of the communities it was trained on, thereby improving its relevance and effectiveness in real-world applications.
Python 5 stars

Alessio-Siciliano/Incremental-Learning-iCarl

Overview: This project is a Python implementation of iCaRL, a method for incremental learning and representation learning. It is based on the paper "Incremental Classifier and Representation Learning" by the authors. Key features: - Reproduces the results from the paper. - Contains two new proposals to improve accuracy. Tech stack: Python, PyTorch v1.5.0. Why it matters: This project is a valuable resource for developers looking to improve their understanding of incremental learning and representation learning techniques.
Jupyter Notebook 5 stars

AlexandreSajus/Intent-Classification

A benchmark of different approaches on the task of Intent Classification

Overview: This repository contains a benchmark of various approaches on the task of Intent Classification using the Silicone MapTask dataset. Key features: - Human Level Performance - Training from Scratch (LSTM) - Fine-Tuning (BERT) - Prompting (GPT-4) Tech stack: Jupyter Notebook Why it matters: This benchmark highlights the performance differences between different models and provides insights into the challenges of Intent Classification, particularly in the context of the Silicone MapTask dataset.