GitHub C++ Weekly Trending

hyprwm/Hyprland

Hyprland is an independent, highly customizable, dynamic tiling Wayland compositor that doesn't sacrifice on its looks.

Hyprland is a 100% independent, dynamic tiling Wayland compositor that doesn't sacrifice on its looks.

It provides the latest Wayland features, is highly customizable, has all the eyecandy, the most powerful plugins, easy IPC, much more QoL stuff than other compositors and more...

Install Quick Start Configure Contribute

Features

All of the eyecandy: gradient borders, blur, animations, shadows and much more
A lot of customization
100% independent, no wlroots, no libweston, no kwin, no mutter.
Custom bezier curves for the best animations
Powerful plugin support
Built-in plugin manager
Tearing support for better gaming performance
Easily expandable and readable codebase
Fast and active development
Not afraid to provide bleeding-edge features
Config reloaded instantly upon saving
Fully dynamic workspaces
Two built-in layouts and more available as plugins
Global keybinds passed to your apps of choice
Tiling/pseudotiling/floating/fullscreen windows
Special workspaces (scratchpads)
Window groups (tabbed mode)
Powerful window/monitor/layer rules
Socket-based IPC
Native IME and Input Panels Support
and much more...

Gallery

Special Thanks

wlroots - For powering Hyprland in the past

tinywl - For showing how 2 do stuff

Sway - For showing how 2 do stuff the overkill way

Vivarium - For showing how 2 do stuff the simple way

dwl - For showing how 2 do stuff the hacky way

Wayfire - For showing how 2 do some graphics stuff

kamyu104/LeetCode-Solutions

🏋️ Python / Modern C++ Solutions of All 3928 LeetCode Problems (Weekly Update)

LeetCode

R.I.P. to my old Leetcode repository, where there were 5.7k+ stars and 2.2k+ forks (ever the top 3 in the field).
Since free questions may be even mistakenly taken down by some companies, only solutions will be post on now.
There are new LeetCode questions every week. I'll keep updating for full summary and better solutions.
For more problem solutions, you can see my LintCode, GoogleKickStart, GoogleCodeJamIO repositories.
For more challenging problem solutions, you can also see my GoogleCodeJam, MetaHackerCup repositories.
Hope you enjoy the journey of learning data structures and algorithms.
Notes: "🔒" means your subscription of LeetCode premium membership is required for reading the question.

Solutions

Algorithms

JavaScript

Database

Pandas

Reference

Links

Bit Manipulation

#	Title	Solution	Time	Space	Difficulty	Tag	Note
3064	Guess the Number Using Bitwise Questions I	C++ Python	O(logn)	O(1)	Medium	🔒	Bit Manipulation
3094	Guess the Number Using Bitwise Questions II	C++ Python	O(logr)	O(1)	Medium	🔒	Bit Manipulation
3125	Maximum Number That Makes Result of Bitwise AND Zero	C++ Python	O(1)	O(1)	Medium	🔒	Bit Manipulation
3133	Minimum Array End	C++ Python	O(logn)	O(1)	Medium		Bit Manipulation
3199	Count Triplets with Even XOR Set Bits I	C++ Python	O(nlogr)	O(1)	Easy	🔒	Brute Force, Bit Manipulation, Parity
3215	Count Triplets with Even XOR Set Bits II	C++ Python	O(nlogr)	O(1)	Medium	🔒	Bit Manipulation, Parity
3226	Number of Bit Changes to Make Two Integers Equal	C++ Python	O(logn)	O(1)	Easy		Bit Manipulation
3289	The Two Sneaky Numbers of Digitville	C++ Python	O(n)	O(1)	Easy		Bit Manipulation
3304	Find the K-th Character in String Game I	C++ Python	O(n)	O(1)	Easy		Bitmasks
3307	Find the K-th Character in String Game II	C++ Python	O(1)	O(1)	Hard		Bitmasks
3314	Construct the Minimum Bitwise Array I	C++ Python	O(n)	O(1)	Easy		Bit Manipulation
3315	Construct the Minimum Bitwise Array II	C++ Python	O(n)	O(1)	Medium		Bit Manipulation
3344	Maximum Sized Array	C++ Python	precompute: O(max_s^(1/5) * log(max_s)) runtime: O(log(max_s))	O(max_s^(1/5))	Medium	🔒	Precompute, Bitmasks, Combinatorics, Binary Search
3370	Smallest Number With All Set Bits	C++ Python	O(1)	O(1)	Easy		Bit Manipulation
3566	Partition Array into Two Equal Product Subsets	C++ Python	O(n 2^n)*	O(1)	Medium		Bitmasks
3632	Subarrays with XOR at Least K	C++ Python	O(nlogr)	O(t)	Hard	🔒	Bitmasks, Prefix Sum, Trie
3646	Next Special Palindrome Number	C++ Python	precompute: O(9 2^9 + 16 * p + plogp)* runtime: O(logp)	O(p)	Hard		Precompute, Bitmasks, Sort, Binary Search
3702	Longest Subsequence With Non-Zero Bitwise XOR	C++ Python	O(n)	O(1)	Medium		Bitmasks
3750	Minimum Number of Flips to Reverse Binary String	C++ Python	O(logn)	O(1)	Easy		Bitmasks
3766	Minimum Operations to Make Binary Palindrome	C++ Python	precompute: O(sqrt(r) logr)* runtime: O(r)	O(r)	Medium		Precompute, Bitmasks, Two Pointers
3769	Sort Integers by Binary Reflection	C++ Python	O(nlogr + nlogn)	O(n)	Easy		Sort, Bitmasks
3782	Last Remaining Integer After Alternating Deletion Operations	C++ Python	O(1)	O(1)	Hard		Bitmasks, Simulation
3827	Count Monobit Integers	C++ Python	O(logn)	O(1)	Easy		Bitmasks

⬆️ Back to Top

Array

#	Title	Solution	Time	Space	Difficulty	Tag	Note
3009	Maximum Number of Intersections on the Chart	C++ Python	O(nlogn)	O(n)	Hard	🔒	Sort, Line Sweep, Coordinate Compression
3010	Divide an Array Into Subarrays With Minimum Cost I	C++ Python	O(n)	O(1)	Easy		Array, Quick Select
3015	Count the Number of Houses at a Certain Distance I	C++ Python	O(n)	O(n)	Medium		Math, Prefix Sum, Difference Array
3017	Count the Number of Houses at a Certain Distance II	C++ Python	O(n)	O(1)	Hard		Math, Prefix Sum, Difference Array
3026	Maximum Good Subarray Sum	C++ Python	O(n)	O(n)	Medium		Prefix Sum
3028	Ant on the Boundary	C++ Python	O(n)	O(1)	Easy		Prefix Sum
3030	Find the Grid of Region Average	C++ Python	O(m n)*	O(m n)*	Medium		Array
3033	Modify the Matrix	C++ Python	O(m n)*	O(1)	Easy		Array
3038	Maximum Number of Operations With the Same Score I	C++ Python	O(n)	O(1)	Easy		Array
3065	Minimum Operations to Exceed Threshold Value I	C++ Python	O(n)	O(1)	Easy		Array
3069	Distribute Elements Into Two Arrays I	C++ Python	O(n)	O(n)	Easy		Array
3070	Count Submatrices with Top-Left Element and Sum Less Than k	C++ Python	O(n m)*	O(1)	Medium		Array, Prefix Sum
3071	Minimum Operations to Write the Letter Y on a Grid	C++ Python	O(n^2)	O(1)	Medium		Array
3079	Find the Sum of Encrypted Integers	C++ Python	O(nlogr)	O(1)	Easy		Array
3096	Minimum Levels to Gain More Points	C++ Python	O(n)	O(n)	Medium		Prefix Sum
3105	Longest Strictly Increasing or Strictly Decreasing Subarray	C++ Python	O(n)	O(1)	Easy		Array
3127	Make a Square with the Same Color	C++ Python	O((n - w + 1)^2 w^2)*	O(1)	Easy		Array
3131	Find the Integer Added to Array I	C++ Python	O(n)	O(1)	Easy		Array
3142	Check if Grid Satisfies Conditions	C++ Python	O(m n)*	O(1)	Easy		Array
3147	Taking Maximum Energy From the Mystic Dungeon	C++ Python	O(n)	O(1)	Medium		Array
3151	Special Array I	C++ Python	O(n)	O(1)	Easy		Array
3152	Special Array II	C++ Python	O(n + q)	O(n)	Medium		Prefix Sum
3153	Sum of Digit Differences of All Pairs	C++ Python	O(nlogr)	O(10 logr)*	Medium		Prefix Sum
3159	Find Occurrences of an Element in an Array	C++ Python	O(n + q)	O(n)	Medium		Array
3173	Bitwise OR of Adjacent Elements	C++ Python	O(n)	O(1)	Easy	🔒	Array
3187	Peaks in Array	C++ Python	O(n + qlogn)	O(n)	Hard		BIT, Fenwick Tree
3195	Find the Minimum Area to Cover All Ones I	C++ Python	O(n m)*	O(1)	Medium		Array
3224	Minimum Array Changes to Make Differences Equal	C++ Python	O(n + k)	O(k)	Medium		Prefix Sum, Difference Array
3279	Maximum Total Area Occupied by Pistons	C++ Python	O(h)	O(h)	Hard	🔒	Line Sweep, Difference Array
3285	Find Indices of Stable Mountains	C++ Python	O(n)	O(1)	Easy		Array
3300	Minimum Element After Replacement With Digit Sum	C++ Python	O(nlogr)	O(1)	Easy		Array
3330	Find the Original Typed String I	C++ Python	O(n)	O(1)	Easy		Array
3334	Find the Maximum Factor Score of Array	C++ Python	O(nlogr)	O(n)	Medium		Prefix Sum
3349	Adjacent Increasing Subarrays Detection I	C++ Python	O(n)	O(1)	Easy		Array
3350	Adjacent Increasing Subarrays Detection II	C++ Python	O(n)	O(1)	Medium		Array
3353	Minimum Total Operations	C++ Python	O(n)	O(1)	Easy	🔒	Array
3354	Make Array Elements Equal to Zero	C++ Python	O(n)	O(n)	Easy	CodeChef Starters 146 - Bouncing Ball	Prefix Sum
3355	Zero Array Transformation I	C++ Python	O(n + q)	O(n)	Medium		Line Sweep
3361	Shift Distance Between Two Strings	C++ Python	O(n + 26)	O(26)	Medium		Prefix Sum
3379	Transformed Array	C++ Python	O(n)	O(1)	Easy		Array
3380	Maximum Area Rectangle With Point Constraints I	C++ Python	O(nlogn)	O(n)	Medium		Sort, Brute Force, BIT, Fenwick Tree, Hash Table
3382	Maximum Area Rectangle With Point Constraints II	C++ Python	O(nlogn)	O(n)	Hard		Sort, BIT, Fenwick Tree, Hash Table
3386	Button with Longest Push Time	C++ Python	O(n)	O(1)	Easy		Array
3392	Count Subarrays of Length Three With a Condition	C++ Python	O(n)	O(1)	Easy		Array
3400	Maximum Number of Matching Indices After Right Shifts	C++ Python	O(n^2)	O(1)	Medium	🔒	Brute Force
3417	Zigzag Grid Traversal With Skip	C++ Python	O(n m)*	O(1)	Easy		Array
3423	Maximum Difference Between Adjacent Elements in a Circular Array	C++ Python	O(n)	O(1)	Easy		Array
3427	Sum of Variable Length Subarrays	C++ Python	O(n)	O(n)	Easy		Difference Array
3432	Count Partitions with Even Sum Difference	C++ Python	O(n)	O(1)	Easy		Prefix Sum
3440	Reschedule Meetings for Maximum Free Time II	C++ Python	O(n)	O(1)	Medium		Array
3446	Sort Matrix by Diagonals	C++ Python	O(n^2 logn)*	O(n^2)	Medium		Array, Sort
3452	Sum of Good Numbers	C++ Python	O(n)	O(1)	Easy		Array
3467	Transform Array by Parity	C++ Python	O(n)	O(1)	Easy		Array
3502	Minimum Cost to Reach Every Position	C++ Python	O(n)	O(1)	Easy		Prefix Sum
3514	Number of Unique XOR Triplets II	C++ Python	O(nlogn)	O(n)	Medium		`Fast Walsh–Hadamard Transform`, FWHT, `Fast Subset Transform`, FST, Hash Table
3531	Count Covered Buildings	C++ Python	O(n)	O(n)	Medium		Array
3537	Fill a Special Grid	C++ Python	O(4^n)	O(1)	Medium		Divide and Conquer, Array
3540	Minimum Time to Visit All Houses	C++ Python	O(n + q)	O(n)	Medium	🔒	Prefix Sum
3546	Equal Sum Grid Partition I	C++ Python	O(m n)*	O(1)	Medium		Array
3548	Equal Sum Grid Partition II	C++ Python	O(m n)*	O(m n)*	Hard		Array, Hash Table
3549	Multiply Two Polynomials	C++ Python	O((n + m) log(n + m))*	O(n + m)	Hard	🔒	`Fast Fourier Transform`, FFT
3550	Smallest Index With Digit Sum Equal to Index	C++ Python	O(nlogr)	O(1)	Easy		Array
3569	Maximize Count of Distinct Primes After Split	C++ Python	O(r + nlogn + qlogn)	O(r + n)	Medium		Number Theory, BST, Sorted List, Segment Tree
3637	Trionic Array I	C++ Python	O(n)	O(1)	Easy		Array
3643	Flip Square Submatrix Vertically	C++ Python	O(k^2)	O(1)	Easy		Array
3653	XOR After Range Multiplication Queries I	C++ Python	O(qlogm + (q + n) sqrt(n))*	O(n sqrt(n))*	Medium		Sqrt Decomposition, Difference Array, Fast Exponentiation, Simulation
3655	XOR After Range Multiplication Queries II	C++ Python	O(qlogm + (q + n) sqrt(n))*	O(n sqrt(n))*	Hard		Sqrt Decomposition, Difference Array, Fast Exponentiation
3674	Minimum Operations to Equalize Array	C++ Python	O(n)	O(1)	Easy		Array
3683	Earliest Time to Finish One Task	C++ Python	O(n)	O(1)	Easy		Array
3687	Library Late Fee Calculator	C++ Python	O(n)	O(1)	Easy	🔒	Array
3688	Bitwise OR of Even Numbers in an Array	C++ Python	O(n)	O(1)	Easy		Array
3696	Maximum Distance Between Unequal Words in Array I	C++ Python	O(n l)*	O(1)	Easy	🔒	Array
3700	Number of ZigZag Arrays II	C++ Python	O((r - l)^3 logn)*	O((r - l)^2)	Hard		Matrix Exponentiation
3701	Compute Alternating Sum	C++ Python	O(n)	O(1)	Easy		Array
3706	Maximum Distance Between Unequal Words in Array II	C++ Python	O(n l)*	O(1)	Medium	🔒	Array
3707	Equal Score Substrings	C++ Python	O(n)	O(1)	Easy		Array, Prefix Sum
3708	Longest Fibonacci Subarray	C++ Python	O(n)	O(1)	Medium		Array
3719	Longest Balanced Subarray I	C++ Python	O(nlogn)	O(n)	Medium		Brute Force, Segment Tree, Binary Search, Prefix Sum
3721	Longest Balanced Subarray II	C++ Python	O(nlogn)	O(n)	Hard		Segment Tree, Binary Search, Prefix Sum
3736	Minimum Moves to Equal Array Elements III	C++ Python	O(n)	O(1)	Easy		Array
3737	Count Subarrays With Majority Element I	C++ Python	O(n)	O(n)	Medium		Freq Table, Prefix Sum
3738	Longest Non-Decreasing Subarray After Replacing at Most One Element	C++ Python	O(n)	O(n)	Medium		Array, Prefix Sum
3739	Count Subarrays With Majority Element II	C++ Python	O(n)	O(n)	Hard		Freq Table, Prefix Sum
3751	Total Waviness of Numbers in Range I	C++ Python	O(nlogn)	O(logn)	Medium		Brute Force
3756	Concatenate Non-Zero Digits and Multiply by Sum II	C++ Python	O(n)	O(n)	Medium		Prefix Sum
3762	Minimum Operations to Equalize Subarrays	C++ Python	O((n + q) logn)*	O(nlogn)	Hard		Prefix Sum, Coordinate Compression, Persistent Segment Tree, Binary Search
3774	Absolute Difference Between Maximum and Minimum K Elements	C++ Python	O(n)	O(1)	Easy		Sort, Quick Select
3788	Maximum Score of a Split	C++ Python	O(n)	O(1)	Medium		Prefix Sum
3809	Best Reachable Tower	C++ Python	O(n)	O(1)	Medium		Array
3814	Maximum Capacity Within Budget	C++ Python	O(n + b)	O(b)	Medium		Hash Table, Prefix Sum, Sort, Mono Stack, Binary Search
3818	Minimum Prefix Removal to Make Array Strictly Increasing	C++ Python	O(n)	O(1)	Medium		Array
3819	Rotate Non Negative Elements	C++ Python	O(n)	O(n)	Medium		Array
3833	Count Dominant Indices	C++ Python	O(n)	O(1)	Easy		Array
3861	Minimum Capacity Box	C++ Python	O(n)	O(1)	Easy		Array
3862	Find the Smallest Balanced Index	C++ Python	O(n)	O(1)	Medium		Prefix Sum
3865	Reverse K Subarrays	C++ Python	O(n)	O(1)	Medium	🔒	Array
3880	Minimum Absolute Difference Between Two Values	C++ Python	O(n)	O(1)	Easy		Array
3898	Find the Degree of Each Vertex	C++ Python	O(n m)*	O(1)	Easy		Array
3903	Smallest Stable Index I	C++ Python	O(n)	O(n)	Easy		Prefix Sum
3904	Smallest Stable Index II	C++ Python	O(n)	O(n)	Medium		Prefix Sum
3907	Count Smaller Elements With Opposite Parity	C++ Python	O(nlogn)	O(n)	Medium	🔒	Sort, Coordinate Compression, BIT, Fenwick Tree
3909	Compare Sums of Bitonic Parts	C++ Python	O(n)	O(1)	Medium		Array
3912	Valid Elements in an Array	C++ Python	O(n)	O(n)	Medium		Prefix Sum
3915	Maximum Sum of Alternating Subsequence With Distance at Least K	C++ Python	O(nlogn)	O(n)	Hard		Sort, Coordinate Compression, BIT, Fenwick Tree, Sliding Window, DP
3918	Sum of Primes Between Number and Its Reverse	C++ Python	precompute: O(r) runtime: O(1)	O(r)	Medium		Number Theory, `Linear Sieve of Eratosthenes`, Prefix Sum
3925	Concatenate Array With Reverse	C++ Python	O(n)	O(1)	Easy		Array

⬆️ Back to Top

String

#	Title	Solution	Time	Space	Difficulty	Tag	Note
3019	Number of Changing Keys	C++ Python	O(n)	O(1)	Easy		String
3023	Find Pattern in Infinite Stream I	C++ Python	O(p + n)	O(p)	Medium	🔒	String, `KMP Algorithm`
3029	Minimum Time to Revert Word to Initial State I	C++ Python	O(n)	O(n)	Medium		String, `Z-Function`, Brute Force
3031	Minimum Time to Revert Word to Initial State II	C++ Python	O(n)	O(n)	Hard		String, `Z-Function`
3034	Number of Subarrays That Match a Pattern I	C++ Python	O(n)	O(m)	Medium		Brute Force, String, `KMP Algorithm`
3036	Number of Subarrays That Match a Pattern II	C++ Python	O(n)	O(m)	Hard		String, `KMP Algorithm`
3037	Find Pattern in Infinite Stream II	C++ Python	O(p + n)	O(p)	Hard	🔒	String, `KMP Algorithm`
3042	Count Prefix and Suffix Pairs I	C++ Python	O(n l)*	O(t)	Easy		Trie, Brute Force
3043	Find the Length of the Longest Common Prefix	C++ Python	O((n + m) l)*	O(t)	Medium		Trie, Hash Table
3045	Count Prefix and Suffix Pairs II	C++ Python	O(n l)*	O(t)	Hard		Trie
3076	Shortest Uncommon Substring in an Array	C++ Python	O(n l^2)*	O(t)	Medium		Trie
3093	Longest Common Suffix Queries	C++ Python	O((n + q) l)*	O(t)	Hard		Trie
3110	Score of a String	C++ Python	O(n)	O(1)	Easy		String
3136	Valid Word	C++ Python	O(n)	O(1)	Easy		String
3163	String Compression III	C++ Python	O(n)	O(1)	Medium		String
3210	Find the Encrypted String	C++ Python	O(n)	O(1)	Medium		String
3271	Hash Divided String	C++ Python	O(n)	O(1)	Medium		String
3280	Convert Date to Binary	C++ Python	O(1)	O(1)	Easy		String
3303	Find the Occurrence of First Almost Equal Substring	C++ Python	O(n + m)	O(n + m)	Hard		`Z-Function`
3324	Find the Sequence of Strings Appeared on the Screen	C++ Python	O(n^2)	O(1)	Medium		String
3340	Check Balanced String	C++ Python	O(n)	O(1)	Easy		String
3407	Substring Matching Pattern	C++ Python	O(n + m)	O(m)	Easy		String, `KMP Algorithm`
3455	Shortest Matching Substring	C++ Python	O(n + m)	O(n + m)	Hard		String, `KMP Algorithm`, Two Pointers
3456	Find Special Substring of Length K	C++ Python	O(n)	O(1)	Easy		String
3491	Phone Number Prefix	C++ Python	O(l nlogn)*	O(1)	Easy	🔒	Trie, Sort
3498	Reverse Degree of a String	C++ Python	O(n)	O(1)	Easy		String
3529	Count Cells in Overlapping Horizontal and Vertical Substrings	C++ Python	O(n m)*	O(n m)*	Medium		`Z-Function`
3571	Find the Shortest Superstring II	C++ Python	O(n + m)	O(n + m)	Easy	🔒	`KMP Algorithm`
3582	Generate Tag for Video Caption	C++ Python	O(n)	O(1)	Easy		String
3598	Longest Common Prefix Between Adjacent Strings After Removals	C++ Python	O(n l)*	O(n)	Medium		LCP, Prefix Sum
3606	Coupon Code Validator	C++ Python	O(l nlogn)*	O(n l)*	Easy		Hash Table, Sort
3744	Find Kth Character in Expanded String	C++ Python	O(n)	O(1)	Medium	🔒	String
3746	Minimum String Length After Balanced Removals	C++ Python	O(n)	O(1)	Medium		String
3748	Count Stable Subarrays	C++ Python	O(n + q)	O(n)	Hard		Prefix Sum
3758	Convert Number Words to Digits	C++ Python	O(n)	O(1)	Medium	🔒	String
3775	Reverse Words With Same Vowel Count	C++ Python	O(n)	O(1)	Medium		String, Inplace
3777	Minimum Deletions to Make Alternating Substring	C++ Python	O((n + q) logn)*	O(n)	Hard		BIT, Fenwick Tree
3794	Reverse String Prefix	C++ Python	O(n)	O(1)	Easy		String
3813	Vowel-Consonant Score	C++ Python	O(n)	O(1)	Easy		String
3823	Reverse Letters Then Special Characters in a String	C++ Python	O(n)	O(1)	Easy		String
3838	Weighted Word Mapping	C++ Python	O(n l)*	O(1)	Easy		String
3856	Trim Trailing Vowels	C++ Python	O(n)	O(1)	Easy		String
3860	Unique Email Groups	C++ Python	O(n l)*	O(n l)*	Medium	🔒	String, Hash Table
3884	First Matching Character From Both Ends	C++ Python	O(n)	O(1)	Medium		String

⬆️ Back to Top

Linked List

#	Title	Solution	Time	Space	Difficulty	Tag	Note
3062	Winner of the Linked List Game	C++ Python	O(n)	O(1)	Easy	🔒	Linked List
3063	Linked List Frequency	C++ Python	O(n)	O(1)	Medium	🔒	Linked List
3217	Delete Nodes From Linked List Present in Array	C++ Python	O(n)	O(m)	Medium		Hash Table, Linked List
3263	Convert Doubly Linked List to Array I	C++ Python	O(n)	O(1)	Easy	🔒	Linked List
3294	Convert Doubly Linked List to Array II	C++ Python	O(n)	O(1)	Medium	🔒	Linked List

⬆️ Back to Top

Stack

#	Title	Solution	Time	Space	Difficulty	Tag	Note
3113	Find the Number of Subarrays Where Boundary Elements Are Maximum	C++ Python	O(n)	O(n)	Hard		Mono Stack, Combinatorics
3174	Clear Digits	C++ Python	O(n)	O(1)	Easy		Stack, Two Pointers
3676	Count Bowl Subarrays	C++ Python	O(n)	O(n)	Medium		Mono Stack
3703	Remove K-Balanced Substrings	C++ Python	O(n)	O(n)	Medium		Stack
3749	Evaluate Valid Expressions	C++ Python	O(n)	O(n)	Hard	🔒	Stack
3834	Merge Adjacent Equal Elements	C++ Python	O(n)	O(1)	Medium		Stack, Simulation
3878	Count Good Subarrays	C++ Python	O(n)	O(n)	Hard		Combinatorics, Mono Stack

⬆️ Back to Top

Queue

#	Title	Solution	Time	Space	Difficulty	Tag	Note

⬆️ Back to Top

Binary Heap

#	Title	Solution	Time	Space	Difficulty	Note
3066	Minimum Operations to Exceed Threshold Value II	C++ Python	O(nlogn)	O(n)	Medium	Simulation, Heap
3080	Mark Elements on Array by Performing Queries	C++ Python	O(q + nlogn)	O(n)	Medium	Hash Table, Heap
3092	Most Frequent IDs	C++ Python	O(nlogn)	O(n)	Medium	Heap, BST, Sorted List
3256	Maximum Value Sum by Placing Three Rooks I	C++ Python	O(m n)*	O(m + n)	Hard	Heap, Brute Force
3257	Maximum Value Sum by Placing Three Rooks II	C++ Python	O(m n)*	O(m + n)	Hard	Heap, Brute Force
3275	K-th Nearest Obstacle Queries	C++ Python	O(qlogk)	O(k)	Medium	Heap
3684	Maximize Sum of At Most K Distinct Elements	C++ Python	O(nlogk)	O(k)	Easy	Heap, Sort
3691	Maximum Total Subarray Value II	C++ Python	O((n + k) logn)*	O(n)	Hard	Heap, Sort, Two Pointers, RMQ, Sparse Table, Segment Tree
3781	Maximum Score After Binary Swaps	C++ Python	O(nlogn)	O(n)	Medium	Heap

⬆️ Back to Top

Tree

#	Title	Solution	Time	Space	Difficulty	Tag	Note
3109	Find the Index of Permutation	C++ Python	O(nlogn)	O(n)	🔒, Medium	variant of Count of Smaller Numbers After Self	BIT, Fenwick Tree, Combinatorics
3515	Shortest Path in a Weighted Tree	C++ Python	O(nlogn)	O(n)	Hard		BIT, Fenwick Tree, DFS
3553	Minimum Weighted Subgraph With the Required Paths II	C++ Python	O(n + q)	O(n + q)	Hard		Tree, DFS, `Tarjan's Offline LCA Algorithm`
3558	Number of Ways to Assign Edge Weights I	C++ Python	O(n)	O(n)	Medium		Tree, BFS, Combinatorics
3559	Number of Ways to Assign Edge Weights II	C++ Python	O(n + q)	O(n + q)	Medium		Tree, DFS, `Tarjan's Offline LCA Algorithm`, Combinatorics
3585	Find Weighted Median Node in Tree	C++ Python	O(n + qlogh)	O(n + q)	Hard		Tree, DFS, `Tarjan's Offline LCA Algorithm`, Binary Search, Prefix Sum
3715	Sum of Perfect Square Ancestors	C++ Python	precompute: O(r) runtime: O(nlogx)	O(r + n)	Hard		Tree, Number Theory, `Linear Sieve of Eratosthenes`, Freq Table, DFS
3841	Palindromic Path Queries in a Tree	C++ Python	O((n + q) logn)*	O(n)	Hard		DFS, HLD, Heavy-Light Decomposition, LCA, Binary Lifting, BIT, Fenwick Tree
3879	Maximum Distinct Path Sum in a Binary Tree	C++ Python	O(n^2)	O(n)	Medium		DFS, BFS

⬆️ Back to Top

Hash Table

#	Title	Solution	Time	Space	Difficulty	Tag	Note
3005	Count Elements With Maximum Frequency	C++ Python	O(n)	O(n)	Easy		Freq Table
3039	Apply Operations to Make String Empty	C++ Python	O(n)	O(1)	Medium		Freq Table
3044	Most Frequent Prime	C++ Python	precompute: O(10^MAX_N_M) runtime: O(n m * (n + m))*	O(10^MAX_N_M + n m * (n + m))*	Medium		Number Theory, `Linear Sieve of Eratosthenes`, Freq Table
3046	Split the Array	C++ Python	O(n)	O(n)	Easy		Freq Table
3078	Match Alphanumerical Pattern in Matrix I	C++ Python	O(n m * r * c)*	O(1)	Medium	🔒	Brute Force, Hash Table
3083	Existence of a Substring in a String and Its Reverse	C++ Python	O(n)	O(min(n, 26^2))	Easy		Hash Table
3120	Count the Number of Special Characters I	C++ Python	O(n + 26)	O(26)	Easy		Hash Table
3121	Count the Number of Special Characters II	C++ Python	O(n + 26)	O(26)	Medium		Hash Table
3137	Minimum Number of Operations to Make Word K-Periodic	C++ Python	O(n)	O(n)	Medium		Freq Table
3138	Minimum Length of Anagram Concatenation	C++ Python	O(sqrt(n) n + 26 * nlogn)*	O(26)	Medium		Number Theory, Freq Table
3143	Maximum Points Inside the Square	C++ Python	O(n + 26)	O(26)	Medium		Hash Table
3146	Permutation Difference between Two Strings	C++ Python	O(n + 26)	O(26)	Easy		Hash Table
3158	Find the XOR of Numbers Which Appear Twice	C++ Python	O(n)	O(n)	Easy		Hash Table
3160	Find the Number of Distinct Colors Among the Balls	C++ Python	O(q)	O(q)	Medium		Freq Table
3167	Better Compression of String	C++ Python	O(n + 26)	O(26)	Medium	🔒	Freq Table, Counting Sort
3184	Count Pairs That Form a Complete Day I	C++ Python	O(n + 24)	O(24)	Easy		Freq Table
3185	Count Pairs That Form a Complete Day II	C++ Python	O(n + 24)	O(24)	Medium		Freq Table
3223	Minimum Length of String After Operations	C++ Python	O(n + 26)	O(26)	Medium		Freq Table
3237	Alt and Tab Simulation	C++ Python	O(n)	O(n)	Medium	🔒	Hash Table
3238	Find the Number of Winning Players	C++ Python	O(p)	O(min(n c, p)*	Easy		Freq Table
3245	Alternating Groups III	C++ Python	O(nlogn + qlogn)	O(n)	Hard		BST, Sorted List, Freq Table, BIT, Fenwick Tree
3295	Report Spam Message	C++ Python	O(n + m)	O(m)	Medium		Hash Table
3365	Rearrange K Substrings to Form Target String	C++ Python	O(n)	O(n)	Medium		Freq Table
3371	Identify the Largest Outlier in an Array	C++ Python	O(n)	O(n)	Medium		Freq Table
3396	Minimum Number of Operations to Make Elements in Array Distinct	C++ Python	O(n + r)	O(r)	Easy		Freq Table
3404	Count Special Subsequences	C++ Python	O(n^2)	O(n^2)	Medium		Freq Table, Number Theory
3438	Find Valid Pair of Adjacent Digits in String	C++ Python	O(n)	O(1)	Easy		Freq Table
3442	Maximum Difference Between Even and Odd Frequency I	C++ Python	O(n + 26)	O(26)	Easy		Freq Table
3450	Maximum Students on a Single Bench	C++ Python	O(n)	O(n)	Easy	🔒	Hash Table, Unordered Set
3471	Find the Largest Almost Missing Integer	C++ Python	O(n)	O(n)	Easy		Freq Table
3487	Maximum Unique Subarray Sum After Deletion	C++ Python	O(n)	O(n)	Easy		Hash Table
3488	Closest Equal Element Queries	C++ Python	O(n)	O(n)	Medium		Hash Table
3527	Find the Most Common Response	C++ Python	O(n l)*	O(n l)*	Medium		Hash Table, Freq Table
3541	Find Most Frequent Vowel and Consonant	C++ Python	O(n + 26)	O(26)	Easy		Freq Table
3572	Maximize Y‑Sum by Picking a Triplet of Distinct X‑Values	C++ Python	O(n)	O(n)	Medium		Hash Table, Quick Select
3581	Count Odd Letters from Number	C++ Python	O(logn)	O(26)	Easy	🔒	Freq Table
3591	Check if Any Element Has Prime Frequency	C++ Python	precompute: O(MAX_N) runtime: O(n)	O(MAX_N)	Easy		Freq Table, Number Theory, `Linear Sieve of Eratosthenes`
3636	Threshold Majority Queries	C++ Python	O(nlogn + qlogq + (n + q) sqrt(n) * logn)*	O(q + n)	Hard		Sort, Coordinate Compression, Sqrt Decomposition, `Mo's Algorithm`, Freq Table, Sorted List, BST
3662	Filter Characters by Frequency	C++ Python	O(n + 26)	O(26)	Easy	🔒	Freq Table
3663	Find The Least Frequent Digit	C++ Python	O(logn + 10)	O(10)	Easy		Freq Table
3668	Restore Finishing Order	C++ Python	O(n + min(8, n))	O(min(8, n))	Easy		Hash Table
3678	Smallest Absent Positive Greater Than Average	C++ Python	O(n)	O(n)	Easy		Hash Table
3682	Minimum Index Sum of Common Elements	C++ Python	O(n + m)	O(n)	Medium	🔒	Hash Table
3692	Majority Frequency Characters	C++ Python	O(n + 26)	O(26)	Easy		Freq Table
3694	Distinct Points Reachable After Substring Removal	C++ Python	O(n)	O(n)	Medium		Hash Table
3712	Sum of Elements With Frequency Divisible by K	C++ Python	O(n)	O(n)	Easy		Freq Table
3713	Longest Balanced Substring I	C++ Python	O(n (a + n))*	O(a)	Medium		Freq Table
3714	Longest Balanced Substring II	C++ Python	O(n)	O(n)	Medium		Hash Table, Prefix Sum
3718	Smallest Missing Multiple of K	C++ Python	O(n)	O(n)	Easy		Hash Table
3728	Stable Subarrays With Equal Boundary and Interior Sum	C++ Python	O(n)	O(n)	Medium		Freq Table, Prefix Sum
3729	Count Distinct Subarrays Divisible by K in Sorted Array	C++ Python	O(n)	O(min(n, k))	Hard		Freq Table, Prefix Sum
3755	Find Maximum Balanced XOR Subarray Length	C++ Python	O(n)	O(n)	Medium		Hash Table, Prefix Sum
3760	Maximum Substrings With Distinct Start	C++ Python	O(n + 26)	O(26)	Medium		Hash Table
3761	Minimum Absolute Distance Between Mirror Pairs	C++ Python	O(nlogr)	O(n)	Medium		Hash Table
3773	Maximum Number of Equal Length Runs	C++ Python	O(n)	O(sqrt(n))	Medium	🔒	Freq Table
3779	Minimum Number of Operations to Have Distinct Elements	C++ Python	O(n)	O(n)	Medium		Hash Table
3784	Minimum Deletion Cost to Make All Characters Equal	C++ Python	O(n + 26)	O(26)	Medium		Freq Table
3803	Count Residue Prefixes	C++ Python	O(n + 26)	O(26)	Easy		Hash Table
3804	Number of Centered Subarrays	C++ Python	O(n^2)	O(n)	Medium		Hash Table
3805	Count Caesar Cipher Pairs	C++ Python	O(n m)*	O(n m)*	Medium		Freq Table
3810	Minimum Operations to Reach Target Array	C++ Python	O(n)	O(n)	Medium		Hash Table
3837	Delayed Count of Equal Elements	C++ Python	O(n)	O(n)	Medium	🔒	Freq Table
3839	Number of Prefix Connected Groups	C++ Python	O(n k)*	O(n k)*	Medium		Freq Table
3842	Toggle Light Bulbs	C++ Python	O(n + r)	O(r)	Easy		Freq Table, Sort
3843	First Element with Unique Frequency	C++ Python	O(n)	O(n)	Medium		Freq Table
3846	Total Distance to Type a String Using One Finger	C++ Python	O(n)	O(n)	Medium	🔒	Hash Table
3848	Check Digitorial Permutation	C++ Python	O(logn + 10)	O(10)	Medium		Freq Table
3852	Smallest Pair With Different Frequencies	C++ Python	O(n)	O(n)	Easy		Freq Table
3866	First Unique Even Element	C++ Python	O(n)	O(n)	Easy		Freq Table
3889	Mirror Frequency Distance	C++ Python	O(n + 36)	O(36)	Medium		Freq Table
3890	Integers With Multiple Sum of Two Cubes	C++ Python	O(n^(2/3) logn)*	O(n^(2/3))	Medium		Brute Force, Freq Table, Sort
3900	Longest Balanced Substring After One Swap	C++ Python	O(n)	O(n)	Medium	variant of Contiguous Array	Hash Table
3901	Good Subsequence Queries	C++ Python	precompute: O(rlog(logr)) runtime: O(r + n + q)	O(rlog(logr) + n)	Medium		Number Theory, Freq Table
3913	Sort Vowels by Frequency	C++ Python	O(n)	O(1)	Medium		Freq Table, Sort
3917	Count Indices With Opposite Parity	C++ Python	O(n)	O(1)	Easy		Freq Table
3921	Score Validator	C++ Python	O(n)	O(1)	Easy		Freq Table
3926	Count Valid Word Occurrences	C++ Python	O(n)	O(n)	Medium		Freq Table

⬆️ Back to Top

Math

#	Title	Solution	Time	Space	Difficulty	Tag	Note
3001	Minimum Moves to Capture The Queen	C++ Python	O(1)	O(1)	Medium		Math
3007	Maximum Number That Sum of the Prices Is Less Than or Equal to K	C++ Python	O(max(logk, x) log((logk) / x))*	O((logk) / x)	Medium		Bit Manipulation, Binary Search, Combinatorics
3021	Alice and Bob Playing Flower Game	C++ Python	O(1)	O(1)	Medium		Combinatorics
3024	Type of Triangle II	C++ Python	O(1)	O(1)	Easy		Math
3032	Count Numbers With Unique Digits II	C++ Python	O(logb)	O(1)	Easy	🔒, variant of Count Numbers With Unique Digits	Brute Force, Hash Table, Bitmasks, Combinatorics
3047	Find the Largest Area of Square Inside Two Rectangles	C++ Python	O(n^2)	O(1)	Meidum		Brute Force, Math
3084	Count Substrings Starting and Ending with Given Character	C++ Python	O(n)	O(1)	Meidum		Combinatorics
3091	Apply Operations to Make Sum of Array Greater Than or Equal to k	C++ Python	O(logn)	O(1)	Meidum	Codeforces Round #674 C	Math
3099	Harshad Number	C++ Python	O(logx)	O(1)	Easy		Math
3102	Minimize Manhattan Distances	C++ Python	O(n)	O(1)	Hard		Math
3115	Maximum Prime Difference	C++ Python	O(r + n)	O(r)	Medium		Array, Number Theory, `Linear Sieve of Eratosthenes`
3128	Right Triangles	C++ Python	O(n m)*	O(min(n, m))	Medium		Array, Combinatorics, Freq Table
3154	Find Number of Ways to Reach the K-th Stair	C++ Python	O(logk)	O(logk)	Hard		Combinatorics
3155	Maximum Number of Upgradable Servers	C++ Python	O(n)	O(1)	Medium	🔒	Math
3162	Find the Number of Good Pairs I	C++ Python	O(rlogr + n + m)	O(r)	Easy		Brute Force, Number Theory, Freq Table
3164	Find the Number of Good Pairs II	C++ Python	O(rlogr + n + m)	O(r)	Medium		Number Theory, Freq Table
3178	Find the Child Who Has the Ball After K Seconds	C++ Python	O(1)	O(1)	Easy		Math
3179	Find the N-th Value After K Seconds	C++ Python	O(n + k)	O(n + k)	Medium		Prefix Sum, Combinatorics
3183	The Number of Ways to Make the Sum	C++ Python	O(1)	O(1)	Medium	🔒	Math, DP
3190	Find Minimum Operations to Make All Elements Divisible by Three	C++ Python	O(n)	O(1)	Easy		Math
3200	Maximum Height of a Triangle	C++ Python	O(logn)	O(1)	Easy		Simulation, Math
3222	Find the Winning Player in Coin Game	C++ Python	O(1)	O(1)	Easy		Math
3227	Vowels Game in a String	C++ Python	O(n)	O(1)	Medium		Math
3232	Find if Digit Game Can Be Won	C++ Python	O(n)	O(1)	Easy		Brute Force, Game Theory
3247	Number of Subsequences with Odd Sum	C++ Python	O(n)	O(1)	Medium	🔒	Combinatorics, Fast Exponentiation, DP
3250	Find the Count of Monotonic Pairs I	C++ Python	O(n + r)	O(n + r)	Hard		Combinatorics, Stars and Bars, DP, Prefix Sum
3251	Find the Count of Monotonic Pairs II	C++ Python	O(n + r)	O(n + r)	Hard		Combinatorics, Stars and Bars, DP, Prefix Sum
3270	Find the Key of the Numbers	C++ Python	O(d)	O(1)	Easy		Math
3272	Find the Count of Good Integers	C++ Python	O(n + 10 10^((n + 1)/2))*	O(n + 10 (10 * nHr(10, n/2)))*	Hard		Combinatorics, Freq Table
3274	Check if Two Chessboard Squares Have the Same Color	C++ Python	O(1)	O(1)	Easy		Math, Parity
3284	Sum of Consecutive Subarrays	C++ Python	O(n)	O(1)	Medium	🔒	Combinatorics
3299	Sum of Consecutive Subsequences	C++ Python	O(n)	O(n)	Hard	🔒	Combinatorics, Prefix Sum, DP
3312	Sorted GCD Pair Queries	C++ Python	O(rlogr + qlogr)	O(r)	Hard		Number Theory, Freq Table, Prefix Sum, Binary Search
3317	Find the Number of Possible Ways for an Event	C++ Python	precompute: O(max_n^2 + max_y min(max_n, max_x))* runtime: O(min(n, x))	O(max_n^2 + max_y min(max_n, max_x))*	Hard		DP, Combinatorics
3326	Minimum Division Operations to Make Array Non Decreasing	C++ Python	precompute: O(r) runtime: O(n)	O(r)	Medium		Greedy, Number Theory, `Linear Sieve of Eratosthenes`
3339	Find the Number of K-Even Arrays	C++ Python	O(n)	O(n)	Medium	🔒	DP, Stars and Bars, Combinatorics
3345	Smallest Divisible Digit Product I	C++ Python	O(logn)	O(1)	Easy		Brute Force
3348	Smallest Divisible Digit Product II	C++ Python	O(n + logt)	O(1)	Hard		Freq Table, Greedy, Prefix Sum, Number Theory
3360	Stone Removal Game	C++ Python	O(1)	O(1)	Easy		Math
3395	Subsequences with a Unique Middle Mode I	C++ Python	O(n)	O(n)	Hard		Freq Table, Prefix Sum, Combinatorics
3405	Count the Number of Arrays with K Matching Adjacent Elements	C++ Python	O(n + logm)	O(n)	Hard		Combinatorics, Fast Exponentiation
3411	Maximum Subarray With Equal Products	C++ Python	precompute: O(r log(logr))* runtime: O(n log(logr))*	O(r log(logr))*	Easy		Number Theory, `Linear Sieve of Eratosthenes`, Hash Table
3416	Subsequences with a Unique Middle Mode II	C++ Python	O(n)	O(n)	Hard	🔒	Freq Table, Prefix Sum, Combinatorics
3426	Manhattan Distances of All Arrangements of Pieces	C++ Python	precompute: O(max(m n))* runtime: O(1)	O(max(m n))*	Hard		Combinatorics
3428	Maximum and Minimum Sums of at Most Size K Subsequences	C++ Python	O(nlogn)	O(n)	Medium		Sort, Combinatorics, Two Pointers, Sliding Window
3447	Assign Elements to Groups with Constraints	C++ Python	O(m + r logn)*	O(r)	Medium		Hash Table, Number Theory
3448	Count Substrings Divisible By Last Digit	C++ Python	O(d n)*	O(d)	Hard		DP, Case Works, Math, Freq Table
3461	Check If Digits Are Equal in String After Operations I	C++ Python	O(nlogn)	O(1)	Easy		Fast Exponentiation, `Luca's Theorem`, Simulation
3463	Check If Digits Are Equal in String After Operations II	C++ Python	O(nlogn)	O(1)	Hard		Fast Exponentiation, `Lucas's Theorem`
3470	Permutations IV	C++ Python	O(n^2)	O(n)	Hard		Combinatorics
3483	Unique 3-Digit Even Numbers	C++ Python	O(n)	O(1)	Easy		Freq Table, Combinatorics
3492	Maximum Containers on a Ship	C++ Python	O(1)	O(1)	Easy		Math
3512	Minimum Operations to Make Array Sum Divisible by K	C++ Python	O(n)	O(1)	Easy		Math
3513	Number of Unique XOR Triplets I	C++ Python	O(logn)	O(1)	Medium		Bit Manipulation, Math
3516	Find Closest Person	C++ Python	O(1)	O(1)	Easy		Math
3519	Count Numbers with Non-Decreasing Digits	C++ Python	O(n^2)	O(n)	Hard		Math, Stars and Bars, Combinatorics
3556	Sum of Largest Prime Substrings	C++ Python	O(n^2 sqrt(r))*	O(n^2)	Medium		Number Theory, Quick Select
3560	Find Minimum Log Transportation Cost	C++ Python	O(1)	O(1)	Easy		Math
3577	Count the Number of Computer Unlocking Permutations	C++ Python	O(n)	O(1)	Medium		Combinatorics
3588	Find Maximum Area of a Triangle	C++ Python	O(n)	O(n)	Medium		Math, Hash Table
3596	Minimum Cost Path with Alternating Directions I	C++ Python	O(1)	O(1)	Medium	🔒	Math
3602	Hexadecimal and Hexatrigesimal Conversion	C++ Python	O(logn)	O(1)	Easy		Math
3618	Split Array by Prime Indices	C++ Python	precompute: O(max_n) runtime: O(n)	O(max_n)	Medium		Number Theory, `Linear Sieve of Eratosthenes`
3621	Number of Integers With Popcount-Depth Equal to K I	C++ Python	precompute: O((logr)^2) runtime: O((logn)^2)	O((logr)^2)	Hard		Combinatorics
3622	Check Divisibility by Digit Sum and Product	C++ Python	O(logn)	O(1)	Easy		Math
3623	Count Number of Trapezoids I	C++ Python	O(n)	O(n)	Medium		Freq Table, Combinatorics
3624	Number of Integers With Popcount-Depth Equal to K II	C++ Python	precompute: O((logr) log(logr))* runtime: O(nlogr + max_k n + nlogn + qlogn)*	O(logr + max_k n)*	Hard		BIT, Fenwick Tree
3625	Count Number of Trapezoids II	C++ Python	O(n^2 logr)*	O(n^2)	Hard		Freq Table, Combinatorics
3648	Minimum Sensors to Cover Grid	C++ Python	O(1)	O(1)	Medium		Math
3658	GCD of Odd and Even Sums	C++ Python	O(1)	O(1)	Easy		Math
3659	Partition Array Into K-Distinct Groups	C++ Python	O(n)	O(n)	Medium		Math, Freq Table
3664	Two-Letter Card Game	C++ Python	O(n + 26)	O(26)	Medium		Math, Freq Table
3666	Minimum Operations to Equalize Binary String	C++ Python	O(n)	O(1)	Hard		Math
3671	Sum of Beautiful Subsequences	C++ Python	precompute: O(rlogr) runtime: O(nlogr (log(nlogr) + logn))*	O(rlogr)	Hard		Number Theory, BIT, Fenwick Tree
3677	Count Binary Palindromic Numbers	C++ Python	O(logn)	O(1)	Hard		Bitmasks, Combinatorics
3697	Compute Decimal Representation	C++ Python	O(logn)	O(1)	Easy		Math
3726	Remove Zeros in Decimal Representation	C++ Python	O(logn)	O(1)	Easy		Math, String
3731	Find Missing Elements	C++ Python	O(n + r)	O(n)	Easy		Hash Table
3745	Maximize Expression of Three Elements	C++ Python	O(n)	O(1)	Easy		Math
3747	Count Distinct Integers After Removing Zeros	C++ Python	O(logn)	O(1)	Medium		Combinatorics
3754	Concatenate Non-Zero Digits and Multiply by Sum I	C++ Python	O(logn)	O(1)	Easy		Math
3765	Complete Prime Number	C++ Python	O(logn sqrt(n))*	O(1)	Medium		Prefix Sum, Number Theory
3770	Largest Prime from Consecutive Prime Sum	C++ Python	precompute: O(r) runtime: O(logp)	O(sqrt(r))	Medium		Precompute, Number Theory, `Linear Sieve of Eratosthenes`, Binary Search
3783	Mirror Distance of an Integer	C++ Python	O(logn)	O(1)	Easy		Math
3789	Minimum Cost to Acquire Required Items	C++ Python	O(1)	O(1)	Medium		Math
3790	Smallest All-Ones Multiple	C++ Python	O(k)	O(1)	Medium	duplicate of Smallest Integer Divisible by K	Math
3798	Largest Even Number	C++ Python	O(n)	O(1)	Easy		Math
3800	Minimum Cost to Make Two Binary Strings Equal	C++ Python	O(n)	O(1)	Medium		Math
3817	Good Indices in a Digit String	C++ Python	O(n)	O(1)	Medium	🔒	Math, Sliding Window
3821	Find Nth Smallest Integer With K One Bits	C++ Python	ctor: O(r^2) runtime: O(r)	O(r^2)	Hard		DP, Combinatorics
3855	Sum of K-Digit Numbers in a Range	C++ Python	O(logr)	O(1)	Hard		Math
3857	Minimum Cost to Split into Ones	C++ Python	O(1)	O(1)	Medium		Combinatorics
3870	Count Commas in Range	C++ Python	O(logn)	O(1)	Easy		Math
3871	Count Commas in Range II	C++ Python	O(logn)	O(1)	Medium		Math
3881	Direction Assignments with Exactly K Visible People	C++ Python	O(n)	O(n)	Medium		Combinatorics
3895	Count Digit Appearances	C++ Python	O(nlogr)	O(1)	Medium		Math
3896	Count Digit Appearances	C++ Python	precompute: O(r), runtime: O(nlogn)	O(r)	Medium		Number Theory, `Linear Sieve of Eratosthenes`, Prime Gap, Binary Search
3899	Angles of a Triangle	C++ Python	O(1)	O(1)	Medium		Math, Law of Cosines
3908	Valid Digit Number	C++ Python	O(logn)	O(1)	Easy		Math
3927	Minimize Array Sum Using Divisible Replacements	C++ Python	O(n + rlogr)	O(r)	Medium		Number Theory

⬆️ Back to Top

Sort

#	Title	Solution	Time	Space	Difficulty	Tag	Note
3011	Find if Array Can Be Sorted	C++ Python	O(n)	O(1)	Medium		Sort
3025	Find the Number of Ways to Place People I	C++ Python	O(n^2)	O(1)	Medium		Sort, Array
3027	Find the Number of Ways to Place People II	C++ Python	O(n^2)	O(1)	Hard		Sort, Array
3081	Replace Question Marks in String to Minimize Its Value	C++ Python	O(n + 26 log(26))*	O(n + 26)	Medium		Greedy, Counting Sort, Heap, Prefix Sum
3132	Find the Integer Added to Array II	C++ Python	O(n)	O(n)	Medium		Sort, Paritial Sort, Freq Table
3169	Count Days Without Meetings	C++ Python	O(nlogn)	O(1)	Medium		Sort
3194	Minimum Average of Smallest and Largest Elements	C++ Python	O(nlogn)	O(1)	Easy		Sort
3309	Maximum Possible Number by Binary Concatenation	C++ Python	O(n logr * logn)*	O(nlogr)	Medium		Sort, Brute Force
3394	Check if Grid can be Cut into Sections	C++ Python	O(nlogn)	O(1)	Medium		Sort, Merge Intervals
3431	Minimum Unlocked Indices to Sort Nums	C++ Python	O(n)	O(1)	Medium		Sort
3551	Minimum Swaps to Sort by Digit Sum	C++ Python	O(nlogr + nlogn)	O(n)	Medium		Sort
3631	Sort Threats by Severity and Exploitability	C++ Python	O(nlogn)	O(1)	Medium	🔒	Sort
3644	Maximum K to Sort a Permutation	C++ Python	O(n)	O(1)	Medium		Sort, Bitmasks, Constructive Algorithms
3667	Sort Array By Absolute Value	C++ Python	O(n + r)	O(n + r)	Easy	🔒	Sort
3759	Count Elements With at Least K Greater Values	C++ Python	O(n)	O(1)	Medium		Sort, Quick Select
3780	Maximum Sum of Three Numbers Divisible by Three	C++ Python	O(n)	O(1)	Medium		Sort, Math
3799	Word Squares II	C++ Python	O(n^4)	O(1)	Medium		Sort, Brute Force, Hash Table
3886	Sum of Sortable Integers	C++ Python	O(nlog(logn))	O(n)	Hard		Prefix Sum, Number Theory

⬆️ Back to Top

Two Pointers

#	Title	Solution	Time	Space	Difficulty	Tag	Note
3006	Find Beautiful Indices in the Given Array I	C++ Python	O(n)	O(min(a + b + x + y, n))	Medium		`KMP Algorithm`, Binary Search, Two Pointers
3008	Find Beautiful Indices in the Given Array II	C++ Python	O(n)	O(min(a + b + x + y, n))	Hard		`KMP Algorithm`, Binary Search, Two Pointers
3013	Divide an Array Into Subarrays With Minimum Cost II	C++ Python	O(nlogd)	O(d)	Hard		Sliding Window, Heap, Freq Table, Ordered Set, BST, Sorted List
3085	Minimum Deletions to Make String K-Special	C++ Python	O(n + 26)	O(n + 26)	Medium		Freq Table, Counting Sort, Two Pointers
3090	Maximum Length Substring With Two Occurrences	C++ Python	O(n + 26)	O(26)	Easy		Freq Table, Sliding Window, Two Pointers
3095	Shortest Subarray With OR at Least K I	C++ Python	O(n 30)*	O(30)	Easy		Brute Force, Freq Table, Two Pointers
3097	Shortest Subarray With OR at Least K II	C++ Python	O(n 30)*	O(30)	Medium		Freq Table, Two Pointers
3171	Find Subarray With Bitwise OR Closest to K	C++ Python	O(nlogr)	O(logr)	Hard	variant of Find a Value of a Mysterious Function Closest to Target	DP, Freq Table, Two Pointers, Sliding Window
3206	Alternating Groups I	C++ Python	O(n)	O(1)	Easy		Two Pointers, Sliding Window
3208	Alternating Groups II	C++ Python	O(n)	O(1)	Medium		Two Pointers, Sliding Window
3234	Count the Number of Substrings With Dominant Ones	C++ Python	O(n^(3/2))	O(1)	Medium		Two Pointers, Sliding Window
3254	Find the Power of K-Size Subarrays I	C++ Python	O(n)	O(1)	Medium		Two Pointers, Sliding Window
3255	Find the Power of K-Size Subarrays II	C++ Python	O(n)	O(1)	Medium		Two Pointers, Sliding Window
3258	Count Substrings That Satisfy K-Constraint I	C++ Python	O(n)	O(1)	Easy		Two Pointers, Sliding Window
3261	Count Substrings That Satisfy K-Constraint II	C++ Python	O(n)	O(n)	Hard		Two Pointers, Sliding Window, Prefix Sum, Hash Table
3264	Final Array State After K Multiplication Operations I	C++ Python	O(nlogn)	O(n)	Easy		Sort, Two Pointers, Sliding Window, Fast Exponentiation, Heap, Binary Search, Simulation
3266	Final Array State After K Multiplication Operations II	C++ Python	O(nlogn)	O(n)	Hard		Sort, Two Pointers, Sliding Window, Fast Exponentiation, Heap, Binary Search
3297	Count Substrings That Can Be Rearranged to Contain a String I	C++ Python	O(n + 26)	O(26)	Medium		Two Pointers, Sliding Window, Freq Table
3298	Count Substrings That Can Be Rearranged to Contain a String II	C++ Python	O(n + 26)	O(26)	Hard		Two Pointers, Sliding Window, Freq Table
3305	Count of Substrings Containing Every Vowel and K Consonants I	C++ Python	O(n)	O(1)	Medium		Two Pointers, Sliding Window, Freq Table
3306	Count of Substrings Containing Every Vowel and K Consonants II	C++ Python	O(n)	O(1)	Medium		Two Pointers, Sliding Window, Freq Table
3318	Find X-Sum of All K-Long Subarrays I	C++ Python	O(nlogn)	O(n)	Easy		Two Pointers, Sliding Window, Freq Table, Ordered Set, Sorted List
3321	Find X-Sum of All K-Long Subarrays II	C++ Python	O(nlogn)	O(n)	Hard		Two Pointers, Sliding Window, Freq Table, Ordered Set, Sorted List
3323	Minimize Connected Groups by Inserting Interval	C++ Python	O(nlogn)	O(n)	Medium	🔒	Sort, Prefix Sum, Two Pointers, Sliding Window
3325	Count Substrings With K-Frequency Characters I	C++ Python	O(n + 26)	O(26)	Medium		Freq Table, Two Pointers, Sliding Window
3329	Count Substrings With K-Frequency Characters II	C++ Python	O(n + 26)	O(26)	Hard	🔒	Freq Table, Two Pointers, Sliding Window
3346	Maximum Frequency of an Element After Performing Operations I	C++ Python	O(nlogn)	O(n)	Medium		Sort, Freq Table, Two Pointers, Sliding Window, Difference Array, Line Sweep
3347	Maximum Frequency of an Element After Performing Operations II	C++ Python	O(nlogn)	O(n)	Hard		Sort, Freq Table, Two Pointers, Sliding Window, Difference Array, Line Sweep
3364	Minimum Positive Sum Subarray	C++ Python	O(nlogn)	O(n)	Easy		Prefix Sum, Two Pointers, Sliding Window, Sorted List, BST, Binary Search
3413	Maximum Coins From K Consecutive Bags	C++ Python	O(nlogn)	O(1)	Medium		Sort, Two Pointers, Sliding Window
3420	Count Non-Decreasing Subarrays After K Operations	C++ Python	O(n)	O(n)	Hard		Mono Deque, Two Pointers, Sliding Window
3422	Minimum Operations to Make Subarray Elements Equal	C++ Python	O(nlogk)	O(k)	Medium	🔒	Math, Two Pointers, Sliding Window, Sorted List, BST
3425	Longest Special Path	C++ Python	O(n + e)	O(n + e)	Hard		DFS, Two Pointers, Sliding Window, Prefix Sum
3430	Maximum and Minimum Sums of at Most Size K Subarrays	C++ Python	O(n)	O(k)	Hard		Two Pointers, Sliding Window, Mono Deque
3439	Reschedule Meetings for Maximum Free Time I	C++ Python	O(n)	O(1)	Medium		Two Pointers, Sliding Window
3445	Maximum Difference Between Even and Odd Frequency II	C++ Python	O(d^2 n)*	O(n)	Hard		Prefix Sum, Two Pointers, Sliding Window
3460	Longest Common Prefix After at Most One Removal	C++ Python	O(n)	O(1)	Medium	🔒	Two Pointers
3485	Longest Common Prefix of K Strings After Removal	C++ Python	O(l nlogn)*	O(n)	Hard		Sort, Sliding Window, Prefix Sum, Trie
3486	Longest Special Path II	C++ Python	O(n + e)	O(n + e)	Hard		DFS, Two Pointers, Sliding Window, Prefix Sum
3555	Smallest Subarray to Sort in Every Sliding Window	C++ Python	O(n)	O(n)	Medium	🔒	Mono Stack, Two Pointers
3567	Minimum Absolute Difference in Sliding Submatrix	C++ Python	O(m n * k^2)*	O(k^2)	Medium		Brute Force, Sort, Two Pointers, Sliding Window, BST, Sorted List
3584	Maximum Product of First and Last Elements of a Subsequence	C++ Python	O(n)	O(1)	Medium		Two Pointers, Sliding Window
3589	Count Prime-Gap Balanced Subarrays	C++ Python	precompute: O(r) runtime: O(n)	O(r)	Medium		Number Theory, `Linear Sieve of Eratosthenes`, Mono Deque, Two Pointers, Sliding Window
3634	Minimum Removals to Balance Array	C++ Python	O(nlogn)	O(1)	Medium		Sort, Two Pointers, Sliding Window
3640	Trionic Array II	C++ Python	O(n)	O(1)	Easy		Two Pointers, Sliding Window, Greedy
3641	Longest Semi-Repeating Subarray	C++ Python	O(n)	O(1)	Medium	🔒	Freq Table, Two Pointers, Sliding Window
3649	Number of Perfect Pairs	C++ Python	O(nlogn)	O(1)	Medium		Sort, Two Pointers, Sliding Window, Math
3652	Best Time to Buy and Sell Stock using Strategy	C++ Python	O(n)	O(1)	Medium		Two Pointers, Sliding Window
3672	Sum of Weighted Modes in Subarrays	C++ Python	O(nlogk)	O(k)	Medium	🔒	Sorted List, BST, Two Pointers, Sliding Window
3679	Minimum Discards to Balance Inventory	C++ Python	O(n)	O(w)	Medium		Freq Table, Two Pointers, Sliding Window
3698	Split Array With Minimum Difference	C++ Python	O(n)	O(1)	Medium		Two Pointers
3740	Minimum Distance Between Three Equal Elements I	C++ Python	O(n)	O(n)	Easy		Hash Table, Two Pointers, Sliding Window
3741	Minimum Distance Between Three Equal Elements II	C++ Python	O(n)	O(n)	Medium		Hash Table, Two Pointers, Sliding Window
3768	Minimum Inversion Count in Subarrays of Fixed Length	C++ Python	O(nlogn)	O(n)	Hard		Sort, Coordinate Compression, BIT, Fenwick Tree, Two Pointers, Sliding Window
3795	Minimum Subarray Length With Distinct Sum At Least K	C++ Python	O(n)	O(n)	Medium		Freq Table, Two Pointers, Sliding Window
3802	Number of Ways to Paint Sheets	C++ Python	O(mlogm)	O(m)	Hard	🔒	Prefix Sum, Two Pointers
3835	Count Subarrays With Cost Less Than or Equal to K	C++ Python	O(n)	O(n)	Medium		Mono Deque, Two Pointers, Sliding Window
3844	Longest Almost-Palindromic Substring	C++ Python	O(n^2)	O(1)	Medium		Two Pointers
3845	Maximum Subarray XOR with Bounded Range	C++ Python	O(nlogr)	O(n)	Hard		Two Pointers, Sliding Window, Mono Deque, Bitmasks, Prefix Sum, Trie, Hash Table
3851	Maximum Requests Without Violating the Limit	C++ Python	O(nlogn)	O(n)	Medium	🔒	Hash Table, Sort, Deque, Two Pointers, Sliding Window
3859	Count Subarrays With K Distinct Integers	C++ Python	O(n)	O(n)	Hard		Freq Table, Two Pointers, Sliding Window
3872	Longest Arithmetic Sequence After Changing At Most One Element	C++ Python	O(n)	O(1)	Medium		Two Pointers
3874	Valid Subarrays With Exactly One Peak	C++ Python	O(n)	O(1)	Medium	🔒	Combinatorics, Two Pointers

⬆️ Back to Top

Recursion

#	Title	Solution	Time	Space	Difficulty	Tag	Note

⬆️ Back to Top

Binary Search

#	Title	Solution	Time	Space	Difficulty	Tag	Note
3048	Earliest Second to Mark Indices I	C++ Python	O(mlogm)	O(n)	Medium		Binary Search, Greedy
3049	Earliest Second to Mark Indices II	C++ Python	O((m + nlogn) logm)*	O(n)	Hard		Binary Search, Greedy, Heap
3104	Find Longest Self-Contained Substring	C++ Python	O(n + 26^3 logn)*	O(n)	Hard	🔒	Brute Force, Freq Table, Two Pointers, Hash Table, Binary Search
3116	Kth Smallest Amount With Single Denomination Combination	C++ Python	O(n 2^n * logk)*	O(2^n)	Hard		Binary Search, Principle of Inclusion and Exclusion, Number Theory
3134	Find the Median of the Uniqueness Array	C++ Python	O(nlogn)	O(n)	Hard		Binary Search, Two Pointers, Sliding Window
3135	Equalize Strings by Adding or Removing Characters at Ends	C++ Python	O((n + m) log(min(n, m)))*	O(min(n, m))	Medium	🔒	Binary Search, `Rabin-Karp Algorithm`, Rolling Hash, DP
3145	Find Products of Elements of Big Array	C++ Python	O(q (logr)^2)*	O(1)	Hard		Binary Search, Combinatorics, Bitmasks, Fast Exponentiation
3231	Minimum Number of Increasing Subsequence to Be Removed	C++ Python	O(nlogn)	O(n)	Hard	🔒, variant of Longest Increasing Subsequence	Binary Search
3233	Find the Count of Numbers Which Are Not Special	C++ Python	precompute: O(sqrt(r)) runtime: O(logr)	O(sqrt(r))	Medium		Number Theory, `Linear Sieve of Eratosthenes`, Binary Search
3281	Maximize Score of Numbers in Ranges	C++ Python	O(nlogr)	O(1)	Medium		Binary Search, Greedy
3288	Length of the Longest Increasing Path	C++ Python	O(nlogn)	O(n)	Hard		Sort, Binary Search, Longest Increasing Subsequence
3296	Minimum Number of Seconds to Make Mountain Height Zero	C++ Python	O(nlogr)	O(1)	Medium		Binary Search, Quadratic Equation, Heap
3356	Zero Array Transformation II	C++ Python	O((n + q) logn)*	O(n)	Medium		Binary Search, Line Sweep
3357	Minimize the Maximum Adjacent Element Difference	C++ Python	O(nlogr)	O(1)	Hard		Binary Search
3398	Smallest Substring With Identical Characters I	C++ Python	O(nlogn)	O(1)	Hard		Binary Search, Greedy
3399	Smallest Substring With Identical Characters II	C++ Python	O(nlogn)	O(1)	Hard		Binary Search, Greedy
3449	Maximize the Minimum Game Score	C++ Python	O(n log(m * r))*	O(1)	Hard		Binary Search, Greedy
3464	Maximize the Distance Between Points on a Square	C++ Python	O(nlogn + nlogs)	O(n)	Hard		Sort, Binary Search, Greedy, Two Pointers, Sliding Window
3477	Fruits Into Baskets II	C++ Python	O(nlogn)	O(n)	Easy		Segment Tree, Binary Search, Brute Force
3479	Fruits Into Baskets III	C++ Python	O(nlogn)	O(n)	Medium		Segment Tree, Binary Search
3520	Minimum Threshold for Inversion Pairs Count	C++ Python	O(nlogn logr)*	O(n)	Medium	🔒	Binary Search, Sorted List, Ordered Set
3605	Minimum Stability Factor of Array	C++ Python	O(nlogn logr)*	O(nlogn)	Hard		Number Theory, Binary Search, RMQ, Sparse Table, Greedy
3722	Lexicographically Smallest String After Reverse	C++ Python	O(nlogn)	O(n)	Medium		String, Brute Force, Binary Search, `Rabin-Karp Algorithm`, Rolling Hash
3733	Minimum Time to Complete All Deliveries	C++ Python	O(logr + logd)	O(1)	Medium		Binary Search
3735	Lexicographically Smallest String After Reverse II	C++ Python	O(nlogn)	O(n)	Hard	🔒	Binary Search, `Rabin-Karp Algorithm`, Rolling Hash
3771	Total Score of Dungeon Runs	C++ Python	O(nlogn)	O(n)	Medium		Prefix Sum, Binary Search
3807	Minimum Cost to Repair Edges to Traverse a Graph	C++ Python	O((n + m) logr)*	O(n + m)	Medium	🔒	Binary Search, BFS
3824	Minimum K to Reduce Array Within Limit	C++ Python	O(nlogn + nlogr)	O(1)	Medium		Binary Search
3825	Longest Strictly Increasing Subsequence With Non-Zero Bitwise AND	C++ Python	O(logr nlogn)*	O(n)	Medium		Bitmasks, LIS, Longest Increasing Subsequence, Binary Search
3826	Minimum Partition Score	C++ Python	O(nlogn + nlogr)	O(n)	Hard		Prefix Sum, DP, Convex Hull Trick, WQS Binary Search, Alien Trick
3893	Maximum Team Size with Overlapping Intervals	C++ Python	O(nlogn)	O(n)	Medium	🔒	Sort, Binary Search
3911	K-th Smallest Remaining Even Integer in Subarray Queries	C++ Python	O(n + qlogn)	O(n)	Hard		Prefix Sum, Binary Search
3920	Maximize Fixed Points After Deletions	C++ Python	O(nlogn)	O(n)	Hard		Sort, Binary Search, Longest Increasing Subsequence
3924	Minimum Threshold Path With Limited Heavy Edges	C++ Python	O((n + e) loge)*	O(n + e)	Hard		Binary Search, 0-1 BFS, Deque

⬆️ Back to Top

Binary Search Tree

#	Title	Solution	Time	Space	Difficulty	Tag	Note
3072	Distribute Elements Into Two Arrays II	C++ Python	O(nlogn)	O(n)	Hard		Sorted List, Ordered Set
3073	Maximum Increasing Triplet Value	C++ Python	O(nlogn)	O(n)	Medium	🔒	Sorted List, BST, Prefix Sum
3161	Block Placement Queries	C++ Python	O(qlogq)	O(q)	Hard		Sorted List, BST, BIT, Fenwick Tree, Segment Tree
3165	Maximum Sum of Subsequence With Non-adjacent Elements	C++ Python	O(n + qlogn)	O(n)	Hard		Segment Tree
3526	Range XOR Queries with Subarray Reversals	C++ Python	O(n + qlogn)	O(n)	Hard	🔒	Treap

⬆️ Back to Top

Breadth-First Search

#	Title	Solution	Time	Space	Difficulty	Tag	Note
3157	Find the Level of Tree with Minimum Sum	C++ Python	O(n)	O(w)	Medium	🔒	BFS
3286	Find a Safe Walk Through a Grid	C++ Python	O(m n)*	O(m n)*	Medium	variant of Minimum Obstacle Removal to Reach Corner	0-1 BFS, Deque
3373	Maximize the Number of Target Nodes After Connecting Trees II	C++ Python	O(n + m)	O(n + m)	Hard		BFS
3528	Unit Conversion I	C++ Python	O(n)	O(n)	Medium		BFS
3535	Unit Conversion II	C++ Python	O(n + qlogm)	O(n)	Medium	🔒	BFS, Fast Exponentiation
3552	Grid Teleportation Traversal	C++ Python	O(m n)*	O(m n)*	Medium		0-1 BFS, Deque
3568	Minimum Moves to Clean the Classroom	C++ Python	O(m n * 2^l)*	O(m n * 2^l)*	Medium		BFS, Bitmasks
3619	Count Islands With Total Value Divisible by K	C++ Python	O(m n)*	O(m + n)	Medium		BFS, Flood Fill
3629	Minimum Jumps to Reach End via Prime Teleportation	C++ Python	precompute: O(r) runtime: O(nlogr)	O(r + nlogr)	Medium		Number Theory, `Linear Sieve of Eratosthenes`, BFS
3690	Split and Merge Array Transformation	C++ Python	O(n^4 n!)*	O(n n!)*	Medium		BFS
3695	Maximize Alternating Sum Using Swaps	C++ Python	O(n + s)	O(n + s)	Hard		BFS, Flood Fill, Quick Select
3786	Total Sum of Interaction Cost in Tree Groups	C++ Python	O(nlogn)	O(n)	Hard		BFS, DFS, Small-to-Large Merging
3787	Find Diameter Endpoints of a Tree	C++ Python	O(n)	O(n)	Medium	🔒	BFS, Tree Diameter
3820	Pythagorean Distance Nodes in a Tree	C++ Python	O(n)	O(n)	Medium		BFS
3831	Median of a Binary Search Tree Level	C++ Python	O(n)	O(n)	Medium	🔒	BFS
3902	Zigzag Level Sum of Binary Tree	C++ Python	O(n)	O(w)	Hard	🔒	BFS
3905	Multi Source Flood Fill	C++ Python	O(n m)*	O(n m)*	Medium		Sort, BFS, Flood Fill
3923	Minimum Generations to Target Point	C++ Python	O(7^6)	O(7^3)	Medium		BFS

⬆️ Back to Top

Depth-First Search

#	Title	Solution	Time	Space	Difficulty	Tag	Note
3004	Maximum Subtree of the Same Color	C++ Python	O(n)	O(h)	Medium	🔒	DFS
3067	Count Pairs of Connectable Servers in a Weighted Tree Network	C++ Python	O(n^2)	O(n)	Medium		DFS, BFS
3203	Find Minimum Diameter After Merging Two Trees	C++ Python	O(n + m)	O(n + m)	Hard	variant of Tree Diameter	DFS, BFS, Tree DP, Tree Diameter
3249	Count the Number of Good Nodes	C++ Python	O(n)	O(h)	Medium		DFS
3319	K-th Largest Perfect Subtree Size in Binary Tree	C++ Python	O(n)	O(n)	Medium		DFS, Quick Select
3327	Check if DFS Strings Are Palindromes	C++ Python	O(n)	O(n)	Hard		DFS, `Manacher's Algorithm`
3331	Find Subtree Sizes After Changes	C++ Python	O(n)	O(n)	Medium		DFS, Hash Table
3367	Maximize Sum of Weights after Edge Removals	C++ Python	O(n)	O(n)	Hard		DFS, Quick Select
3590	Kth Smallest Path XOR Sum	C++ Python	O(n (logn)^2 + qlogn)*	O(n + q)	Hard		DFS, Small-to-Large Merging, Ordered Set, Sorted List
3593	Minimum Increments to Equalize Leaf Paths	C++ Python	O(n)	O(n)	Medium		DFS
3607	Power Grid Maintenance	C++ Python	O(c + n + q)	O(c + n)	Medium		DFS, Flood Fill, Sort

⬆️ Back to Top

Backtracking

#	Title	Solution	Time	Space	Difficulty	Tag	Note
3211	Generate Binary Strings Without Adjacent Zeros	C++ Python	O(n 2^n)*	O(n)	Medium		Backtracking, BFS
3437	Permutations III	C++ Python	O(n n!)*	O(n)	Medium	🔒	Backtracking, Bitmasks
3565	Sequential Grid Path Cover	C++ Python	O(m n * 3^(m * n))*	O(m n)*	Medium	🔒	Backtracking
3669	Balanced K-Factor Decomposition	C++ Python	precompute: O(rlogr) runtime: O(k (logn)^(k - 1))*	O(rlogr)	Medium		Backtracking, Number Theory

⬆️ Back to Top

Dynamic Programming

#	Title	Solution	Time	Space	Difficulty	Tag	Note
3018	Maximum Number of Removal Queries That Can Be Processed I	C++ Python	O(n^2)	O(n^2)	Hard	🔒	DP
3020	Find the Maximum Number of Elements in Subset	C++ Python	O(n)	O(n)	Medium		Freq Table, DP
3040	Maximum Number of Operations With the Same Score II	C++ Python	O(n^2)	O(n^2)	Medium		Memoization
3041	Maximize Consecutive Elements in an Array After Modification	C++ Python	O(nlogn)	O(1)	Hard		Sort, DP
3077	Maximum Strength of K Disjoint Subarrays	C++ Python	O(k n)*	O(n)	Hard		DP, Greedy, `Kadane's Algorithm`
3082	Find the Sum of the Power of All Subsequences	C++ Python	O(n k)*	O(k)	Hard		DP, Combinatorics
3098	Find the Sum of Subsequence Powers	C++ Python	O(n^3 k)*	O(n^2)	Hard		DP, Prefix Sum, Two Pointers
3101	Count Alternating Subarrays	C++ Python	O(n)	O(1)	Medium		DP
3117	Minimum Sum of Values by Dividing Array	C++ Python	O(n m * logr)*	O(n + logr)	Hard		Memoization, DP, RMQ, Sparse Table, Mono Deque, Two Pointers
3122	Minimum Number of Operations to Satisfy Conditions	C++ Python	O(n (m + 10))*	O(10)	Medium		DP
3129	Find All Possible Stable Binary Arrays I	C++ Python	O(n m)*	O(n m)*	Medium		DP
3130	Find All Possible Stable Binary Arrays II	C++ Python	O(n m)*	O(n m)*	Hard		DP
3141	Maximum Hamming Distances	C++ Python	O(m 2^m)*	O(2^m)	Hard	🔒	Bitmasks, BFS, Knapsack DP
3144	Minimum Substring Partition of Equal Character Frequency	C++ Python	O(n (n + 26))*	O(n + 26)	Medium		DP, Freq Table
3148	Maximum Difference Score in a Grid	C++ Python	O(m n)*	O(1)	Medium		DP
3149	Find the Minimum Cost Array Permutation	C++ Python	O((n-1)^2 2^(n-1))*	O((n-1) 2^(n-1))*	Hard		DP, Backtracing
3176	Find the Maximum Length of a Good Subsequence I	C++ Python	O(n k)*	O(n k)*	Medium		DP
3177	Find the Maximum Length of a Good Subsequence II	C++ Python	O(n k)*	O(n k)*	Hard		DP
3180	Maximum Total Reward Using Operations I	C++ Python	O(n k)*	O(n k)*	Medium		Sort, DP, Bitset
3181	Maximum Total Reward Using Operations II	C++ Python	O(n k)*	O(n k)*	Hard		Sort, DP, Bitset
3186	Maximum Total Damage With Spell Casting	C++ Python	O(nlogn)	O(n)	Medium		Sort, DP, Two Pointers, Sliding window, Deque
3193	Count the Number of Inversions	C++ Python	O(n k)*	O(n + k)	Hard	variant of K Inverse Pairs Array	Knapsack DP, Combinatorics, Sliding Window, Two Pointers
3196	Maximize Total Cost of Alternating Subarrays	C++ Python	O(n)	O(1)	Medium		DP
3197	Find the Minimum Area to Cover All Ones II	C++ Python	O(max(n, m)^2)	O(max(n, m)^2)	Hard		Array, Brute Force, Prefix Sum, Binary Search, RMQ, Sparse Table, DP
3201	Find the Maximum Length of Valid Subsequence I	C++ Python	O(n)	O(1)	Medium		Brute Force, DP
3202	Find the Maximum Length of Valid Subsequence II	C++ Python	O(n k)*	O(k)	Medium		DP
3209	Number of Subarrays With AND Value of K	C++ Python	O(nlogr)	O(logr)	Hard	variant of Find Subarray With Bitwise OR Closest to K	DP
3212	Count Submatrices With Equal Frequency of X and Y	C++ Python	O(n m)*	O(n m)*	Medium		DP
3213	Construct String with Minimum Cost	C++ Python	O(n^2 + w l)*	O(t)	Hard		DP, Trie
3225	Maximum Score From Grid Operations	C++ Python	O(n^3)	O(n)	Hard		Prefix Sum, DP
3241	Time Taken to Mark All Nodes	C++ Python	O(n)	O(n)	Hard		Tree DP, BFS, DFS
3253	Construct String with Minimum Cost (Easy)	C++ Python	O(n w * l)*	O(l)	Medium	🔒	DP, Trie
3259	Maximum Energy Boost From Two Drinks	C++ Python	O(n)	O(1)	Medium		DP
3269	Constructing Two Increasing Arrays	C++ Python	O(m n)*	O(min(m, n))	Hard	🔒	DP
3277	Maximum XOR Score Subarray Queries	C++ Python	O(n^2 + q)	O(n^2)	Hard		DP
3283	Maximum Number of Moves to Kill All Pawns	C++ Python	O(p^2 2^p)*	O(p 2^p)*	Hard		BFS, Bitmasks, DP
3287	Find the Maximum Sequence Value of Array	C++ Python	O(n r + r^2)*	O(r)	Hard		Bitmasks, Prefix Sum, DP
3290	Maximum Multiplication Score	C++ Python	O(n)	O(1)	Medium		DP
3291	Minimum Number of Valid Strings to Form Target I	C++ Python	O(n + w l)*	O(n + t)	Medium		KMP, `Rabin-Karp Algorithm`, Rolling Hash, Hash Table, Two Pointers, Sliding Window, DP, `Aho-Corasick Automata`, Trie
3292	Minimum Number of Valid Strings to Form Target II	C++ Python	O(n + w l)*	O(n + t)	Hard		KMP, `Rabin-Karp Algorithm`, Rolling Hash, Hash Table, Two Pointers, Sliding Window, DP, `Aho-Corasick Automata`, Trie
3313	Find the Last Marked Nodes in Tree	C++ Python	O(n)	O(n)	Hard	🔒, variant of Time Taken to Mark All Nodes	BFS, DFS, Tree DP, Tree Diameter
3316	Find Maximum Removals From Source String	C++ Python	O(n m)*	O(n + m)	Medium		DP
3320	Count The Number of Winning Sequences	C++ Python	O(n^2)	O(n)	Hard		DP
3332	Maximum Points Tourist Can Earn	C++ Python	O(k n^2)*	O(n)	Hard		DP
3333	Find the Original Typed String II	C++ Python	O(n + k^2)	O(n + k)	Hard		DP
3335	Total Characters in String After Transformations I	C++ Python	precompute: O(t + 26) runtime: O(n)	O(t + 26)	Medium		DP, Matrix Exponentiation, Precompute
3336	Find the Number of Subsequences With Equal GCD	C++ Python	precompute: O(max_r^2 log(max_r))* runtime: O(n + r^2)	O(max_r^2)	Hard		DP, Number Theory, Mobius Function, Principle of Inclusion-Exclusion, `Basel Problem`
3337	Total Characters in String After Transformations II	C++ Python	O(n + 26^3 logt)*	O(26^2)	Hard		DP, Matrix Exponentiation
3343	Count Number of Balanced Permutations	C++ Python	O(n^2)	O(n^2)	Hard		DP, Combinatorics
3351	Sum of Good Subsequences	C++ Python	O(n)	O(n)	Hard		Freq Table, DP
3352	Count K-Reducible Numbers Less Than N	C++ Python	O(n^2)	O(n)	Hard		DP, Combinatorics
3359	Find Sorted Submatrices With Maximum Element at Most K	C++ Python	O(m n)*	O(m)	Hard	🔒, variant of Count Submatrices With All Ones	Mono Stack, DP
3363	Find the Maximum Number of Fruits Collected	C++ Python	O(n^2)	O(1)	Hard		DP
3366	Minimum Array Sum	C++ Python	O(nlogn)	O(n)	Medium		DP, Greedy, Case Works
3372	Maximize the Number of Target Nodes After Connecting Trees I	C++ Python	O(nlogn + mlogm)	O(n + m)	Medium		Brute Force, BFS, DFS, Tree DP, Centroid Decomposition, Prefix Sum
3381	Maximum Subarray Sum With Length Divisible by K	C++ Python	O(n)	O(k)	Medium		Prefix Sum, DP
3388	Count Beautiful Splits in an Array	C++ Python	O(n^2)	O(n)	Medium		DP, `Z-Function`
3389	Minimum Operations to Make Character Frequencies Equal	C++ Python	O(26 n)*	O(26)	Hard		Freq Table, DP
3393	Count Paths With the Given XOR Value	C++ Python	O(m n * r)*	O(n r)*	Medium		DP
3409	Longest Subsequence With Decreasing Adjacent Difference	C++ Python	O(r^2 + n r)*	O(r^2)	Medium		DP
3414	Maximum Score of Non-overlapping Intervals	C++ Python	O(nlogn + n k^2)*	O(n k^2)*	Hard		DP, Binary Search
3418	Maximum Amount of Money Robot Can Earn	C++ Python	O(m n)*	O(min(m, n))	Medium		DP
3429	Paint House IV	C++ Python	O(n l^4)*	O(l^2)	Medium		DP
3434	Maximum Frequency After Subarray Operation	C++ Python	O(n)	O(n)	Medium		Freq Table, DP
3441	Minimum Cost Good Caption	C++ Python	O(26 n)*	O(26 n)*	Hard		DP, Backtracing
3444	Minimum Increments for Target Multiples in an Array	C++ Python	O(logr m * 2^m + n * 3^m)*	O(2^m)	Hard		Bitmasks, Number Theory, DP, Submask Enumeration
3459	Length of Longest V-Shaped Diagonal Segment	C++ Python	O(n m)*	O(n m)*	Hard		Memoization, DP
3466	Maximum Coin Collection	C++ Python	O(n)	O(1)	Medium	🔒	DP
3469	Find Minimum Cost to Remove Array Elements	C++ Python	O(n^2)	O(n)	Medium		DP, Greedy
3472	Longest Palindromic Subsequence After at Most K Operations	C++ Python	O(n^2 k)*	O(n^2 k)*	Medium		DP
3473	Sum of K Subarrays With Length at Least M	C++ Python	O(k n)*	O(n)	Medium		Prefix Sum, DP
3489	Zero Array Transformation IV	C++ Python	O(n^2 r * logq)*	O(r)	Medium		Binary Search, DP
3490	Count Beautiful Numbers	C++ Python	O(logr 2 * 10 * s)*	O(logr 2 * 10 * s)*	Hard		DP
3500	Minimum Cost to Divide Array Into Subarrays	C++ Python	O(nlogn)	O(n)	Hard		Prefix Sum, DP, Convex Hull Trick
3503	Longest Palindrome After Substring Concatenation I	C++ Python	O(n m)*	O(n + m)	Medium		`Manacher's Algorithm`, DP
3504	Longest Palindrome After Substring Concatenation II	C++ Python	O(n m)*	O(n + m)	Hard		`Manacher's Algorithm`, DP
3505	Minimum Operations to Make Elements Within K Subarrays Equal	C++ Python	O(nlogx + k n)*	O(n)	Hard		Two Heaps, Two BSTs, Two Sorted Lists, DP
3509	Maximum Product of Subsequences With an Alternating Sum Equal to K	C++ Python	O(n k * l)*	O(n k * l)*	Hard		DP
3524	Find X Value of Array I	C++ Python	O(n k)*	O(k)	Medium		DP
3525	Find X Value of Array II	C++ Python	O(n k + q * k * logn)*	O(n k)*	Hard		DP, Segment Tree
3530	Maximum Profit from Valid Topological Order in DAG	C++ Python	O(n 2^n)*	O(2^n)	Hard		DP, Bitmasks
3533	Concatenated Divisibility	C++ Python	O(nlogr + k n * 2^n)*	O(logr + k 2^n)*	Hard		DP, Bitmasks, Backtracing
3538	Merge Operations for Minimum Travel Time	C++ Python	O((n-k) k^3)*	O(k^2)	Hard		Prefix Sum, DP
3539	Find Sum of Array Product of Magical Sequences	C++ Python	O(n k * m^2)*	O(k m^2)*	Hard		DP, Combinatorics
3543	Maximum Weighted K-Edge Path	C++ Python	O(k e * t)*	O(n t)*	Medium		DP
3544	Subtree Inversion Sum	C++ Python	O(n)	O(n)	Hard		DFS, Tree DP
3562	Maximum Profit from Trading Stocks with Discounts	C++ Python	O(n b)*	O(n + b)	Hard		DFS, Tree DP
3563	Lexicographically Smallest String After Adjacent Removals	C++ Python	O(n^3)	O(n^2)	Hard		DP
3573	Best Time to Buy and Sell Stock V	C++ Python	O(n k)*	O(k)	Medium		DP
3574	Maximize Subarray GCD Score	C++ Python	O(nlogn logr)*	O(n + logr)	Hard		Brute Force, Number Theory, Suffix-GCD States, DP, Binary Search
3575	Maximum Good Subtree Score	C++ Python	O(n (2^10)^2)*	O(2^10)	Hard		Bitmasks, DFS, Tree DP
3578	Count Partitions With Max-Min Difference at Most K	C++ Python	O(n)	O(n)	Medium		Mono Deque, Two Pointers, Sliding Window, DP, Prefix Sum
3579	Minimum Steps to Convert String with Operations	C++ Python	O(n^2)	O(26^2)	Hard		DP
3583	Count Special Triplets	C++ Python	O(n)	O(n)	Medium		DP, Freq Table
3592	Inverse Coin Change	C++ Python	O(n^2)	O(1)	Medium		DP
3595	Once Twice	C++ Python	O(n)	O(1)	Medium	🔒	DP, Bitmasks
3599	Partition Array to Minimize XOR	C++ Python	O(n^2 k)*	O(n)	Medium		DP, Prefix Sum
3603	Minimum Cost Path with Alternating Directions II	C++ Python	O(m n)*	O(1)	Medium		DP
3610	Minimum Number of Primes to Sum to Target	C++ Python	O(nlog(log(min(m, n))) + m n)*	O(n)	Medium	🔒	Number Theory, Knapsack DP
3615	Longest Palindromic Path in Graph	C++ Python	O(n^4 2^n)*	O(n + e)	Hard		Bitmasks, DP, Freq Table
3628	Maximum Number of Subsequences After One Inserting	C++ Python	O(n)	O(1)	Medium		Prefix Sum, DP
3647	Maximum Weight in Two Bags	C++ Python	O(n w1 * w2)*	O(w1 w2)*	Medium	🔒	DP, Bitset
3651	Minimum Cost Path with Teleportations	C++ Python	O(k (m * n + r))*	O(m n + r)*	Hard		DP, Prefix Sum
3654	Minimum Sum After Divisible Sum Deletions	C++ Python	O(n + k)	O(k)	Medium		DP, Prefix Sum
3661	Maximum Walls Destroyed by Robots	C++ Python	O(nlogn + mlogm)	O(n)	Hard		Sort, DP, Two Pointers
3665	Twisted Mirror Path Count	C++ Python	O(m n)*	O(min(m, n))	Medium		DP
3670	Maximum Product of Two Integers With No Common Bits	C++ Python	O(n + rlogr)	O(r)	Medium		DP, Bitmasks
3685	Subsequence Sum After Capping Elements	C++ Python	O(nlogn + n k)*	O(k)	Medium		Sort, DP, Bitmasks
3686	Number of Stable Subsequences	C++ Python	O(n)	O(1)	Hard		DP
3693	Climbing Stairs II	C++ Python	O(n)	O(1)	Medium		DP
3699	Number of ZigZag Arrays I	C++ Python	O(n (r - l))*	O(r - l)	Hard		DP
3704	Count No-Zero Pairs That Sum to N	C++ Python	O(10 2^4 * logn)*	O(2^3)	Hard		DP
3717	Minimum Operations to Make the Array Beautiful	C++ Python	O(n rlogr)*	O(r)	Medium	🔒	DP
3725	Count Ways to Choose Coprime Integers from Rows	C++ Python	O(n rlogr)*	O(r)	Hard		DP, Number Theory, `Linear Sieve of Eratosthenes`, Mobius Function, Principle of Inclusion-Exclusion
3742	Maximum Path Score in a Grid	C++ Python	O(m n * k)*	O(m n * k)*	Medium		DP
3743	Maximize Cyclic Partition Score	C++ Python	O(n k)*	O(k)	Hard	variant of Best Time to Buy and Sell Stock V	DP
3753	Total Waviness of Numbers in Range II	C++ Python	O(logn 11 * 11 * 2 * 2 * 10)*	O(11 11 * 2 * 2)*	Hard		DP, Memoization
3757	Number of Effective Subsequences	C++ Python	O((n + r) logr)*	O(n + r)	Hard		SOS DP, Principle of Inclusion and Exclusion
3772	Maximum Subgraph Score in a Tree	C++ Python	O(n)	O(n)	Hard		BFS, Tree DP
3791	Number of Balanced Integers in a Range	C++ Python	O((logn)^2)	O(logn)	Hard		DP, Memoization
3801	Minimum Cost to Merge Sorted Lists	C++ Python	O(l nlogn + 2^n * log(n * l) * n * logl + 3^n)*	O(n l + 2^n)*	Hard		DP, Sort, Heap, Binary Search, Submask Enumeration
3811	Number of Alternating XOR Partitions	C++ Python	O(n)	O(1)	Medium		DP, Freq Table
3830	Longest Alternating Subarray After Removing At Most One Element	C++ Python	O(n)	O(1)	Hard		DP, Prefix Sum
3836	Maximum Score Using Exactly K Pairs	C++ Python	O(n m * k)*	O(min(n, m) k)*	Hard		DP
3840	House Robber V	C++ Python	O(n)	O(1)	Medium		DP
3850	Count Sequences to K	C++ Python	O(3^(n/2))	O(3^(n/2))	Hard		DP, Meet in The Middle
3864	Minimum Cost to Partition a Binary String	C++ Python	O(n)	O(n)	Hard		Prefix Sum, Divide and Conquer, DP
3869	Count Fancy Numbers in a Range	C++ Python	O(g d + d^2)*	O(g + d)	Hard		BFS, DP, Principle of Inclusion and Exclusion
3877	Minimum Removals to Achieve Target XOR	C++ Python	O(n r)*	O(r)	Medium		Bitmasks, DP, BFS
3882	Minimum XOR Path in a Grid	C++ Python	O(m n * r)*	O(n r)*	Medium		DP
3883	Count Non Decreasing Arrays With Given Digit Sums	C++ Python	precompute: O(rlogr) runtime: O(n r)*	O(r)	Medium		DP, Prefix Sum
3891	Minimum Increase to Maximize Special Indices	C++ Python	O(n)	O(1)	Medium		DP
3906	Count Good Integers on a Grid Path	C++ Python	O(16 2 * 10 * 10)*	O(16 + 2 10)*	Hard		Memoization, DP
3916	Number of ZigZag Arrays III	C++ Python	O(n^3)	O(n)	Hard	🔒	DP, Prefix Sum, Combinatorics, `Lagrange Interpolation`

⬆️ Back to Top

Greedy

#	Title	Solution	Time	Space	Difficulty	Tag	Note
3002	Maximum Size of a Set After Removals	C++ Python	O(n)	O(n)	Medium		Math, Hash Table, Greedy
3003	Maximize the Number of Partitions After Operations	C++ Python	O(n)	O(n)	Hard		Prefix Sum, Greedy
3012	Minimize Length of Array Using Operations	C++ Python	O(n)	O(1)	Medium		Greedy
3014	Minimum Number of Pushes to Type Word I	C++ Python	O(4)	O(1)	Easy		Freq Table, Greedy
3016	Minimum Number of Pushes to Type Word II	C++ Python	O(n)	O(26)	Medium		Freq Table, Greedy
3022	Minimize OR of Remaining Elements Using Operations	C++ Python	O(nlogr)	O(1)	Hard		Bitmasks, Greedy
3035	Maximum Palindromes After Operations	C++ Python	O(n l + nlogn)*	O(n)	Medium		Freq Table, Greedy, Sort
3068	Find the Maximum Sum of Node Values	C++ Python	O(n)	O(1)	Hard		Greedy
3074	Apple Redistribution into Boxes	C++ Python	O(nlogn)	O(1)	Easy		Sort, Greedy
3075	Maximize Happiness of Selected Children	C++ Python	O(nlogn)	O(1)	Medium		Sort, Greedy
3086	Minimum Moves to Pick K Ones	C++ Python	O(n)	O(n)	Hard		Prefix Sum, Greedy
3088	Make String Anti-palindrome	C++ Python	O(n + 26)	O(26)	Hard	🔒	Freq Table, Counting Sort, Greedy, Two Pointers
3106	Lexicographically Smallest String After Operations With Constraint	C++ Python	O(n)	O(1)	Medium		Greedy
3107	Minimum Operations to Make Median of Array Equal to K	C++ Python	O(n)	O(1)	Medium		Sort, Quick Select, Greedy
3111	Minimum Rectangles to Cover Points	C++ Python	O(nlogn)	O(n)	Medium		Sort, Greedy
3114	Latest Time You Can Obtain After Replacing Characters	C++ Python	O(1)	O(1)	Easy		String, Greedy
3119	Maximum Number of Potholes That Can Be Fixed	C++ Python	O(n)	O(n)	Medium	🔒	Sort, Counting Sort, Greedy
3170	Lexicographically Minimum String After Removing Stars	C++ Python	O(n + 26)	O(n + 26)	Medium		Greedy, Hash Table, Stack
3189	Minimum Moves to Get a Peaceful Board	C++ Python	O(n)	O(n)	Medium	🔒, variant of Distribute Coins in Binary Tree	Counting Sort, Prefix Sum, Greedy
3191	Minimum Operations to Make Binary Array Elements Equal to One I	C++ Python	O(n)	O(1)	Medium		Greedy
3192	Minimum Operations to Make Binary Array Elements Equal to One II	C++ Python	O(n)	O(1)	Medium		Greedy
3205	Maximum Array Hopping Score I	C++ Python	O(n)	O(1)	Medium	🔒	DP, Prefix Sum, Greedy
3207	Maximum Points After Enemy Battles	C++ Python	O(n)	O(1)	Medium		Greedy
3216	Lexicographically Smallest String After a Swap	C++ Python	O(n)	O(1)	Easy		Greedy
3218	Minimum Cost for Cutting Cake I	C++ Python	O(mlogm + nlogn)	O(1)	Medium		Memoization, Greedy
3219	Minimum Cost for Cutting Cake II	C++ Python	O(mlogm + nlogn)	O(1)	Hard		Greedy
3221	Maximum Array Hopping Score II	C++ Python	O(n)	O(1)	Medium	🔒	Prefix Sum, Greedy
3228	Maximum Number of Operations to Move Ones to the End	C++ Python	O(n)	O(1)	Medium		Greedy
3229	Minimum Operations to Make Array Equal to Target	C++ Python	O(n)	O(1)	Hard	variant of Minimum Number of Increments on Subarrays to Form a Target Array	Greedy
3239	Minimum Number of Flips to Make Binary Grid Palindromic I	C++ Python	O(m n)*	O(1)	Medium		Array, Greedy
3240	Minimum Number of Flips to Make Binary Grid Palindromic II	C++ Python	O(m n)*	O(1)	Medium		Array, Greedy
3273	Minimum Amount of Damage Dealt to Bob	C++ Python	O(nlogn)	O(n)	Hard		Sort, Greedy
3282	Reach End of Array With Max Score	C++ Python	O(n)	O(1)	Medium		Greedy
3301	Maximize the Total Height of Unique Towers	C++ Python	O(nlogn)	O(1)	Medium		Sort, Greedy
3302	Find the Lexicographically Smallest Valid Sequence	C++ Python	O(n + m)	O(m)	Medium		Hash Table, Greedy
3362	Zero Array Transformation III	C++ Python	O(n + qlogq)	O(q)	Medium		Sort, Heap, Greedy
3397	Maximum Number of Distinct Elements After Operations	C++ Python	O(nlogn)	O(1)	Medium		Sort, Greedy
3402	Minimum Operations to Make Columns Strictly Increasing	C++ Python	O(m n)*	O(1)	Easy		Greedy
3403	Find the Lexicographically Largest String From the Box I	C++ Python	O(n)	O(1)	Medium		Greedy
3406	Find the Lexicographically Largest String From the Box II	C++ Python	O(n)	O(1)	Hard	🔒	Greedy
3410	Maximize Subarray Sum After Removing All Occurrences of One Element	C++ Python	O(n)	O(n)	Hard		Prefix Sum, Greedy, `Kadane's Algorithm`, Segment Tree
3424	Minimum Cost to Make Arrays Identical	C++ Python	O(nlogn)	O(1)	Medium		Sort, Greedy
3443	Maximum Manhattan Distance After K Changes	C++ Python	O(n)	O(1)	Medium		Greedy
3457	Eat Pizzas!	C++ Python	O(nlogn)	O(1)	Medium		Sort, Greedy
3458	Select K Disjoint Special Substrings	C++ Python	O(n + 26^3)	O(26)	Medium		Hash Table, Sort, Greedy
3462	Maximum Sum With at Most K Elements	C++ Python	O(n m)*	O(1)	Medium		Greedy, Quick Select
3468	Find the Number of Copy Arrays	C++ Python	O(n)	O(1)	Medium		Greedy
3474	Lexicographically Smallest Generated String	C++ Python	O(n + m)	O(n + m)	Hard		`KMP Algorithm`, `Z-Function`, Two Pointers, Sliding Window, Deque, Greedy
3476	Maximize Profit from Task Assignment	C++ Python	O(n + tlogt)	O(n)	Medium	🔒	Freq Table, Sort, Greedy
3478	Choose K Elements With Maximum Sum	C++ Python	O(nlogn)	O(n)	Medium		Sort, Greedy, Two Pointers, Heap
3480	Maximize Subarrays After Removing One Conflicting Pair	C++ Python	O(n + m)	O(n + m)	Hard		Greedy
3494	Find the Minimum Amount of Time to Brew Potions	C++ Python	O(n m)*	O(1)	Medium		Prefix Sum, Greedy
3494	Find the Minimum Amount of Time to Brew Potions	C++ Python	O(n m)*	O(1)	Medium		Prefix Sum, Greedy
3495	Minimum Operations to Make Array Elements Zero	C++ Python	O(qlogr)	O(1)	Hard		Greedy
3496	Maximize Score After Pair Deletions	C++ Python	O(n)	O(1)	Medium	🔒	Greedy
3499	Maximize Active Section with Trade I	C++ Python	O(n)	O(1)	Medium		Greedy
3501	Maximize Active Section with Trade II	C++ Python	O(nlogn + q)	O(nlogn)	Hard		Greedy, RMQ, Sparse Table
3506	Find Time Required to Eliminate Bacterial Strains	C++ Python	O(nlogn)	O(1)	Hard	🔒	Heap, Greedy
3511	Make a Positive Array	C++ Python	O(n)	O(1)	Medium	🔒	Prefix Sum, Greedy
3517	Smallest Palindromic Rearrangement I	C++ Python	O(n + 26)	O(26)	Medium		Freq Table, Counting Sort, Greedy
3518	Smallest Palindromic Rearrangement II	C++ Python	O(26 n)*	O(26)	Hard		Freq Table, Counting Sort, Greedy, Combinatorics
3523	Make Array Non-decreasing	C++ Python	O(n)	O(1)	Medium		Greedy
3542	Minimum Operations to Convert All Elements to Zero	C++ Python	O(n)	O(n)	Medium		Greedy, Mono Stack
3545	Minimum Deletions for At Most K Distinct Characters	C++ Python	O(n + 26)	O(n + 26)	Easy		Freq Table, Counting Sort, Greedy
3557	Find Maximum Number of Non Intersecting Substrings	C++ Python	O(n)	O(26)	Medium		Greedy, Hash Table
3576	Transform Array to All Equal Elements	C++ Python	O(n)	O(1)	Medium		Greedy
3587	Minimum Adjacent Swaps to Alternate Parity	C++ Python	O(n)	O(1)	Medium		Greedy
3627	Maximum Median Sum of Subsequences of Size 3	C++ Python	O(nlogn)	O(1)	Medium		Sort, Greedy
3630	Partition Array for Maximum XOR and AND	C++ Python	O(nlogr 2^n)*	O(1)	Hard		Bitmasks, Greedy
3633	Earliest Finish Time for Land and Water Rides I	C++ Python	O(n)	O(1)	Easy		Greedy
3635	Earliest Finish Time for Land and Water Rides II	C++ Python	O(n)	O(1)	Medium		Greedy
3638	Maximum Balanced Shipments	C++ Python	O(n)	O(1)	Medium		Greedy
3645	Maximum Total from Optimal Activation Order	C++ Python	O(nlogn)	O(n)	Medium		Sort, Greedy
3675	Minimum Operations to Transform String	C++ Python	O(n)	O(1)	Medium		Greedy
3681	Maximum XOR of Subsequences	C++ Python	O(nlogr)	O(r)	Hard		Bitmasks, Greedy
3689	Maximum Total Subarray Value I	C++ Python	O(n)	O(1)	Medium		Greedy
3711	Maximum Transactions Without Negative Balance	C++ Python	O(nlogn)	O(n)	Medium	🔒	Greedy, Heap
3720	Lexicographically Smallest Permutation Greater Than Target	C++ Python	O(26 n)*	O(26)	Medium		Freq Table, Greedy
3723	Maximize Sum of Squares of Digits	C++ Python	O(n)	O(1)	Medium		Greedy
3724	Minimum Operations to Transform Array	C++ Python	O(n)	O(1)	Medium		Greedy
3727	Maximum Alternating Sum of Squares	C++ Python	O(n)	O(n)	Medium		Greedy, Sort, Quick Select
3730	Maximum Calories Burnt from Jumps	C++ Python	O(nlogn)	O(1)	Medium	🔒	Greedy, Sort
3732	Maximum Product of Three Elements After One Replacement	C++ Python	O(n)	O(1)	Medium		Greedy
3734	Lexicographically Smallest Palindromic Permutation Greater Than Target	C++ Python	O(26 n)*	O(26)	Hard		Freq Table, Greedy
3752	Lexicographically Smallest Negated Permutation that Sums to Target	C++ Python	O(n)	O(1)	Medium		Greedy, Two Pointers
3763	Maximum Total Sum with Threshold Constraints	C++ Python	O(n)	O(n)	Medium	🔒	Sort, Counting Sort, Greedy
3767	Maximize Points After Choosing K Tasks	C++ Python	O(n)	O(n)	Medium		Greedy, Sort, Quick Select
3776	Minimum Moves to Balance Circular Array	C++ Python	O(n)	O(1)	Medium		Greedy
3785	Minimum Swaps to Avoid Forbidden Values	C++ Python	O(n)	O(1)	Hard		`Boyer–Moore Majority Vote Algorithm`, Freq Table, Greedy
3796	Find Maximum Value in a Constrained Sequence	C++ Python	O(n)	O(n)	Medium		Greedy, DP
3797	Count Routes to Climb a Rectangular Grid	C++ Python	O(n m)*	O(m)	Hard		DP, Two Pointers
3806	Maximum Bitwise AND After Increment Operations	C++ Python	O(nlogr)	O(n)	Hard		Bitmasks, Greedy, Sort, Quick Select
3812	Minimum Edge Toggles on a Tree	C++ Python	O(n)	O(n)	Hard		Greedy, Topological Sort, Bitmasks
3816	Lexicographically Smallest String After Deleting Duplicate Characters	C++ Python	O(n + 26)	O(26)	Hard		Freq Table, Greedy
3828	Final Element After Subarray Deletions	C++ Python	O(1)	O(1)	Medium		Greedy, Game Theory
3849	Maximum Bitwise XOR After Rearrangement	C++ Python	O(n)	O(1)	Medium		Greedy
3854	Minimum Operations to Make Array Parity Alternating	C++ Python	O(n)	O(1)	Medium		Greedy
3858	Minimum Bitwise OR From Grid	C++ Python	O(nlogr)	O(1)	Medium		Bitmasks, Greedy
3863	Minimum Operations to Sort a String	C++ Python	O(n)	O(1)	Medium		Greedy
3868	Minimum Cost to Equalize Arrays Using Swaps	C++ Python	O(n)	O(n)	Medium		Freq Table, Greedy
3888	Minimum Operations to Make All Grid Elements Equal	C++ Python	O(m n)*	O(k n)*	Hard	🔒	Sliding Window, Greedy, Difference Array
3892	Minimum Operations to Achieve At Least K Peaks	C++ Python	O(n + klogn)	O(n)	Hard		Greedy, Heap, Doubly Linked List
3897	Maximum Value of Concatenated Binary Segments	C++ Python	O(r + nlogn)	O(r + n)	Hard		Greedy
3914	Minimum Operations to Make Array Non Decreasing	C++ Python	O(n)	O(1)	Medium		Greedy
3919	Minimum Cost to Move Between Indices	C++ Python	O(n)	O(n)	Medium		Greedy, Prefix Sum
3922	Minimum Flips to Make Binary String Coherent	C++ Python	O(n)	O(1)	Medium		Greedy, Case Works

⬆️ Back to Top

Graph

#	Title	Solution	Time	Space	Difficulty	Tag	Note
3108	Minimum Cost Walk in Weighted Graph	C++ Python	O(n + e + q)	O(n)	Hard		Union Find
3112	Minimum Time to Visit Disappearing Nodes	C++ Python	O(\|E\| log\|V\|)*	O(\|E\|)	Medium		Graph, `Dijkstra's Algorithm`
3123	Find Edges in Shortest Paths	C++ Python	O(\|E\| log\|V\|)*	O(\|E\|)	Hard		Graph, `Dijkstra's Algorithm`
3235	Check if the Rectangle Corner Is Reachable	C++ Python	O(n^2)	O(n)	Hard		Graph, BFS, DFS, Union Find
3243	Shortest Distance After Road Addition Queries I	C++ Python	O(n^2)	O(n^2)	Medium		Graph, `Dijkstra's Algorithm`, BFS
3244	Shortest Distance After Road Addition Queries II	C++ Python	O(nlogn)	O(n)	Hard		Graph, BST, Sorted List
3265	Count Almost Equal Pairs I	C++ Python	O(n l^2)*	O(n)	Medium		Freq Table, Combinatorics, Graph, BFS
3267	Count Almost Equal Pairs II	C++ Python	O(n l^4)*	O(n)	Hard		Freq Table, Combinatorics, Graph, BFS
3276	Select Cells in Grid With Maximum Score	C++ Python	O(n^2 max(n, r))*	O(n max(n, r))*	Hard	variant of Maximum Compatibility Score Sum	`Hungarian Weighted Bipartite Matching`, DP, Bitmasks
3310	Remove Methods From Project	C++ Python	O(n + e)	O(n + e)	Medium		Graph, BFS
3341	Find Minimum Time to Reach Last Room I	C++ Python	O(n m * log(n * m))*	O(n m)*	Medium		Graph, `Dijkstra's Algorithm`
3342	Find Minimum Time to Reach Last Room II	C++ Python	O(n m * log(n * m))*	O(n m)*	Medium		Graph, `Dijkstra's Algorithm`
3377	Digit Operations to Make Two Integers Equal	C++ Python	O(nlogn)	O(n)	Medium		Graph, Number Theory, `Linear Sieve of Eratosthenes`, `Dijkstra's Algorithm`
3378	Count Connected Components in LCM Graph	C++ Python	O(n + tlogt)	O(t)	Hard		Number Theory, Graph, Union Find
3383	Minimum Runes to Add to Cast Spell	C++ Python	O(n)	O(n)	Hard	🔒	Graph, `Tarjan's Strongly Connected Components Algorithm`, SCC
3376	Minimum Time to Break Locks I	C++ Python	O(n^3)	O(n^2)	Medium		Bitmasks, DP, Graph, `Hungarian Weighted Bipartite Matching`
3385	Minimum Time to Break Locks II	C++ Python	O(n^3)	O(n^2)	Hard	🔒	Graph, `Hungarian Weighted Bipartite Matching`
3387	Maximize Amount After Two Days of Conversions	C++ Python	O(n^2)	O(n)	Medium		`Bellman-Ford Algorithm`, BFS
3419	Minimize the Maximum Edge Weight of Graph	C++ Python	O(nlogn + e)	O(n + e)	Medium		Graph, `Dijkstra's Algorithm`, `Prim's Algorithm`, Binary Search, BFS
3435	Frequencies of Shortest Supersequences	C++ Python	O(n + k^2 2^k)*	O(k^2)	Hard		Bitmasks, Graph, Topological Sort
3481	Apply Substitutions	C++ Python	O(r 2^r)*	O(r 2^r)*	Medium	🔒	Graph, Topological Sort, Memoization
3493	Properties Graph	C++ Python	O(n^2 m)*	O(n)	Medium		Graph, Flood Fill, BFS, Union Find
3532	Path Existence Queries in a Graph I	C++ Python	O(n + q)	O(n)	Medium		Prefix Sum
3534	Path Existence Queries in a Graph II	C++ Python	O((n + q) logn)*	O(nlogn)	Hard		Prefix Sum, Greedy, Binary Lifting
3536	Maximum Product of Two Digits	C++ Python	O(d + 10)	O(10)	Easy		Freq Table, Greedy
3547	Maximum Sum of Edge Values in a Graph	C++ Python	O(n)	O(n)	Hard		Flood Fill, BFS, Counting Sort, Greedy
3594	Minimum Time to Transport All Individuals	C++ Python	O(m 3^n * log(m * 3^n))*	O(m 3^n)*	Hard		Graph, `Dijkstra's Algorithm`, Submask Enumeration
3600	Maximize Spanning Tree Stability with Upgrades	C++ Python	O(n + eloge)	O(n)	Hard		MST, Maximum Spanning Tree, Union Find, `Kruskal's Algorithm`, Greedy
3604	Minimum Time to Reach Destination in Directed Graph	C++ Python	O(n + elogn)	O(n + e)	Medium		Graph, `Dijkstra's Algorithm`
3620	Network Recovery Pathways	C++ Python	O((n + e) logr)*	O(n + e)	Hard		Binary Search, Topological Sort, DP
3650	Minimum Cost Path with Edge Reversals	C++ Python	O(n + elogn)	O(n + e)	Medium		Graph, `Dijkstra's Algorithm`
3656	Determine if a Simple Graph Exists	C++ Python	O(nlogn)	O(1)	Medium	🔒	Graph, `Erdős–Gallai Theorem`, Sort, Prefix sum, Two Pointers
3660	Jump Game IX	C++ Python	O(n)	O(1)	Medium		Graph, Prefix Sum
3710	Maximum Partition Factor	C++ Python	O(n^2 logn)*	O(n^2)	Hard		Graph, Sort, Coordinate Compression, Binary Search, BFS, Greedy, Union Find
3778	Minimum Distance Excluding One Maximum Weighted Edge	C++ Python	O(n + elogn)	O(n + e)	Medium	🔒	Graph, `Dijkstra's Algorithm`
3873	Maximum Points Activated with One Addition	C++ Python	O(n)	O(n)	Hard		Graph, Union Find
3887	Incremental Even-Weighted Cycle Queries	C++ Python	O(n + e)	O(n)	Hard		Graph, Union Find
3910	Count Connected Subgraphs with Even Node Sum	C++ Python	O((n + e) 2^n)*	O(n + e)	Hard		Graph, Bitmask, DFS
3928	Minimum Cost to Buy Apples II	C++ Python	O(n (n + elogn))*	O(n + e)	Hard		Graph, `Dijkstra's Algorithm`

⬆️ Back to Top

Geometry

#	Title	Solution	Time	Space	Difficulty	Tag	Note
3453	Separate Squares I	C++ Python	O(nlogn)	O(n)	Medium		Binary Search, Sort, Line Sweep
3454	Separate Squares II	C++ Python	O(nlogn)	O(n)	Hard		Sort, Line Sweep, Segment Tree

⬆️ Back to Top

Simulation

#	Title	Solution	Time	Space	Difficulty	Tag	Note
3100	Water Bottles II	C++ Python	O(sqrt(n))	O(1)	Medium		Simulation
3168	Minimum Number of Chairs in a Waiting Room	C++ Python	O(n)	O(1)	Easy		Simulation
3175	Find The First Player to win K Games in a Row	C++ Python	O(n)	O(1)	Medium		Simulation
3248	Snake in Matrix	C++ Python	O(c)	O(1)	Medium		Simulation
3412	Find Mirror Score of a String	C++ Python	O(n + 26)	O(n + 26)	Medium		Simulation, Hash Table, Stack
3433	Count Mentions Per User	C++ Python	O(eloge + e n)*	O(e + n)	Medium		Simulation
3507	Minimum Pair Removal to Sort Array I	C++ Python	O(nlogn)	O(n)	Easy		Simulation, Doubly Linked List, Sorted List, BST
3510	Minimum Pair Removal to Sort Array II	C++ Python	O(nlogn)	O(n)	Hard		Simulation, Doubly Linked List, Sorted List, BST
3522	Calculate Score After Performing Instructions	C++ Python	O(n)	O(n)	Medium		Simulation
3561	Resulting String After Adjacent Removals	C++ Python	O(n)	O(1)	Medium		Simulation, Stack
3597	Partition String	C++ Python	O(n)	O(t)	Medium		Simulation, Trie
3608	Minimum Time for K Connected Components	C++ Python	O(n + eloge)	O(n)	Medium		Backward Simulation, Sort, Union Find
3609	Minimum Moves to Reach Target in Grid	C++ Python	O(logtx + logty)	O(1)	Hard		Backward Simulation
3612	Process String with Special Operations I	C++ Python	O(r)	O(r)	Medium		Simulation, Deque
3613	Minimize Maximum Component Cost	C++ Python	O(n + eloge)	O(n)	Medium		Backward Simulation, Sort, Union Find
3614	Process String with Special Operations II	C++ Python	O(n)	O(1)	Hard		Backward Simulation
3616	Number of Student Replacements	C++ Python	O(n)	O(1)	Medium	🔒	Simulation
3639	Minimum Time to Activate String	C++ Python	O(n)	O(n)	Medium		Backward Simulation, Doubly Linked List
3792	Sum of Increasing Product Blocks	C++ Python	O(n^2)	O(n^2)	Medium	🔒	Simulation, Math
3847	Find the Score Difference in a Game	C++ Python	O(n)	O(1)	Medium		Simulation
3853	Merge Close Characters	C++ Python	O(n + 26)	O(26)	Medium		Simulation, Freq Table, Two Pointers, Sliding Window
3867	Sum of GCD of Formed Pairs	C++ Python	O(nlogr)	O(n)	Medium		Simulation, Prefix sum, Sort, Two Pointers
3894	Traffic Signal Color	C++ Python	O(1)	O(1)	Easy		Simulation

⬆️ Back to Top

Constructive Algorithms

#	Title	Solution	Time	Space	Difficulty	Note
3139	Minimum Cost to Equalize Array	C++ Python	O(n)	O(1)	Hard	Constructive Algorithms, Math
3260	Find the Largest Palindrome Divisible by K	C++ Python	O(n)	O(1)	Hard	String, Constructive Algorithms, Math
3311	Construct 2D Grid Matching Graph Layout	C++ Python	O(n)	O(n)	Hard	Graph, Constructive Algorithms, BFS
3375	Minimum Operations to Make Array Values Equal to K	C++ Python	O(n)	O(n)	Easy	Hash Table, Constructive Algorithms
3680	Generate Schedule	C++ Python	O(n^2)	O(1)	Medium	Constructive Algorithms
3875	Construct Uniform Parity Array I	C++ Python	O(1)	O(1)	Easy	Constructive Algorithms
3876	Construct Uniform Parity Array II	C++ Python	O(n)	O(1)	Medium	Constructive Algorithms

⬆️ Back to Top

Design

#	Title	Solution	Time	Space	Difficulty	Tag	Note
3242	Design Neighbor Sum Service	C++ Python	ctor: O(n^2) adjacentSum: O(1) diagonalSum: O(1)	O(n^2)	Easy		Hash Table
3369	Design an Array Statistics Tracker	C++ Python	ctor: O(1) addNumber: O(logn) removeFirstAddedNumber: O(logn) getMean: O(1) getMedian: O(1) getMode: O(1)	O(n)	Hard	🔒	Deque, Freq Table, Sorted List, BST
3391	Design a 3D Binary Matrix with Efficient Layer Tracking	C++ Python	ctor: O(1) setCell: O(logn) unsetCell: O(logn) largestMatrix: O(logn)	O(n^3)	Medium	🔒	Heap, Sorted List
3408	Design Task Manager	C++ Python	ctor: O(tlogt) add: O(logt) edit: O(logt) rmv: O(logt) execTop: O(logt)	O(t)	Medium		Sorted List
3484	Design Spreadsheet	C++ Python	ctor: O(1) setCell: O(1) resetCell: O(1) getValue: O(1)	O(n)	Medium		Hash Table
3508	Implement Router	C++ Python	ctor: O(1) addPacket: O(logn) forwardPacket: O(logn) getCount: O(logn)	O(n)	Medium		Queue, Sorted List, Ordered Set
3709	Design Exam Scores Tracker	C++ Python	ctor: O(1) record: O(1) totalScore: O(logn)	O(n)	Medium		Prefix Sum, Binary Search
3815	Design Auction System	C++ Python	ctor: O(1) addBid: O(logn) updateBid: O(logn) removeBid: O(logn) getHighestBidder: O(1)	O(n)	Medium		Hash Table, Heap, Sorted List, BST
3822	Design Order Management System	C++ Python	ctor: O(1) addOrder: O(1) modifyOrder: O(1) cancelOrder: O(1) getOrdersAtPrice: O(n)	O(n)	Medium	🔒	Hash Table
3829	Design Ride Sharing System	C++ Python	ctor: O(1) addRider: O(1) addDriver: O(1) matchDriverWithRider: O(1) cancelRider: O(1)	O(n)	Medium		Ordered Dict
3885	Design Event Manager	C++ Python	ctor: O(n) updatePriority: O(logn) pollHightest: O(logn)	O(n)	Medium		Sorted List, BST, Heap, Hash Table

⬆️ Back to Top

JS

#	Title	Solution	Time	Space	Difficulty	Tag	Note

⬆️ Back to Top

SQL

#	Title	Solution	Time	Space	Difficulty	Tag	Note
3050	Pizza Toppings Cost Analysis	MySQL	O(n^3 logn)*	O(n^3)	Medium	🔒
3051	Find Candidates for Data Scientist Position	MySQL	O(nlogn)	O(n)	Easy	🔒
3052	Maximize Items	MySQL	O(n)	O(n)	Hard	🔒
3053	Classifying Triangles by Lengths	MySQL	O(n)	O(n)	Easy	🔒
3054	Binary Tree Nodes	MySQL	O(nlogn)	O(n)	Medium	🔒
3055	Top Percentile Fraud	MySQL	O(nlogn)	O(n)	Medium	🔒
3056	Snaps Analysis	MySQL	O(n)	O(n)	Medium	🔒
3057	Employees Project Allocation	MySQL	O(nlogn)	O(n)	Hard	🔒
3058	Friends With No Mutual Friends	MySQL	O(n^2 logn)*	O(n^2)	Medium	🔒
3059	Find All Unique Email Domains	MySQL	O(nlogn)	O(n)	Easy	🔒
3060	User Activities within Time Bounds	MySQL	O(nlogn)	O(n)	Hard	🔒
3061	Calculate Trapping Rain Water	MySQL	O(nlogn)	O(n)	Hard	🔒
3087	Find Trending Hashtags	MySQL	O(nlogn)	O(n)	Medium	🔒
3089	Find Bursty Behavior	MySQL	O(nlogn)	O(n)	Medium	🔒	Window Function
3103	Find Trending Hashtags II	MySQL	O(n l^2 + (n * l) * log(n * l))*	O(n l^2)*	Hard	🔒	Recursive CTE
3118	Friday Purchase III	MySQL	O(n)	O(n)	Medium	🔒
3124	Find Longest Calls	MySQL	O(nlogn)	O(n)	Medium	🔒	Window Function
3126	Server Utilization Time	MySQL	O(nlogn)	O(n)	Medium		Window Function
3140	Consecutive Available Seats II	MySQL	O(nlogn)	O(n)	Medium	🔒	Window Function
3150	Invalid Tweets II	MySQL	O(n l + nlogn)*	O(n l)*	Easy	🔒	String
3156	Employee Task Duration and Concurrent Tasks	MySQL	O(nlogn)	O(n)	Hard	🔒	Line Sweep
3166	Calculate Parking Fees and Duration	MySQL	O(nlogn)	O(n)	Medium	🔒
3172	Second Day Verification	MySQL	O(nlogn)	O(n)	Easy	🔒
3182	Find Top Scoring Students	MySQL	O(nlogn)	O(n)	Medium	🔒
3188	Find Top Scoring Students II	MySQL	O(nlogn)	O(n)	Hard	🔒
3198	Find Cities in Each State	MySQL	O(nlogn)	O(n)	Easy	🔒
3204	Bitwise User Permissions Analysis	MySQL	O(n)	O(n)	Medium	🔒
3214	Year on Year Growth Rate	MySQL	O(nlogn)	O(n)	Hard	🔒	Window Function
3220	Odd and Even Transactions	MySQL	O(nlogn)	O(n)	Medium
3230	Customer Purchasing Behavior Analysis	MySQL	O(nlogn)	O(n)	Medium	🔒	Window Function
3236	CEO Subordinate Hierarchy	MySQL	O(nlogn)	O(n)	Hard	🔒	Recursive CTE, BFS
3246	Premier League Table Ranking	MySQL	O(nlogn)	O(n)	Easy	🔒	Window Function
3252	Premier League Table Ranking II	MySQL	O(nlogn)	O(n)	Medium	🔒	Window Function
3262	Find Overlapping Shifts	MySQL	O(nlogn)	O(n)	Medium	🔒	Line Sweep
3268	Find Overlapping Shifts II	MySQL	O(n^2)	O(n^2)	Hard	🔒	Line Sweep, Window Function, Combinatorics
3278	Find Candidates for Data Scientist Position II	MySQL	O(p s * n + p * nlogn + plogp)*	O(p s * n)*	Medium	🔒	Window Function
3293	Calculate Product Final Price	MySQL	O(nlogn)	O(n)	Medium	🔒
3308	Find Top Performing Driver	MySQL	O(tlogt)	O(t)	Medium	🔒	Window Function
3322	Premier League Table Ranking III	MySQL	O(nlogn)	O(n)	Medium	🔒	Window Function
3328	Find Cities in Each State II	MySQL	O(nlogn)	O(n)	Medium	🔒
3338	Second Highest Salary II	MySQL	O(nlogn)	O(n)	Medium	🔒	Window Function
3358	Books with NULL Ratings	MySQL	O(nlogn)	O(n)	Easy	🔒
3368	First Letter Capitalization	MySQL	O(n l^2 + (n * l) * log(n * l))*	O(n l^2)*	Hard	🔒	Recursive CTE
3374	First Letter Capitalization II	MySQL	O(n l^2 + (n * l) * log(n * l))*	O(n l^2)*	Hard	🔒	Recursive CTE
3384	Team Dominance by Pass Success	MySQL	O(plogp + t)	O(p + t)	Hard	🔒
3390	Longest Team Pass Streak	MySQL	O(plogp + t)	O(p + t)	Hard	🔒	Recursive CTE, Window Function
3401	Find Circular Gift Exchange Chains	MySQL	O(n^2)	O(n^2)	Hard	🔒	Recursive CTE, Window Function
3415	Find Products with Three Consecutive Digits	MySQL	O(nlogn)	O(n)	Easy	🔒	Regular Expression
3421	Find Students Who Improved	MySQL	O(nlogn)	O(n)	Medium	🔒	Window Function
3436	Find Valid Emails	MySQL	O(n)	O(n)	Easy		Regular Expression
3451	Find Invalid IP Addresses	MySQL	O(nlogn)	O(n)	Hard		Regular Expression
3465	Find Products with Valid Serial Numbers	MySQL	O(nlogn)	O(n)	Easy		Regular Expression
3475	DNA Pattern Recognition	MySQL	O(nlogn)	O(n)	Medium		Regular Expression
3482	Analyze Organization Hierarchy	MySQL	O(n^2)	O(n^2)	Hard		Recursive CTE, BFS
3497	Analyze Subscription Conversion	MySQL	O(nlogn)	O(n)	Medium
3521	Find Product Recommendation Pairs	MySQL	O(n^2 logn)*	O(n^2)	Medium
3554	Find Category Recommendation Pairs	MySQL	O(n^2 logn)*	O(n^2)	Hard
3564	Seasonal Sales Analysis	MySQL	O(nlogn)	O(n)	Medium		Window Function
3570	Find Books with No Available Copies	MySQL	O(nlogn)	O(n)	Easy
3580	Find Consistently Improving Employees	MySQL	O(nlogn)	O(n)	Medium		Window Function
3586	Find COVID Recovery Patients	MySQL	O(n^2)	O(n^2)	Medium
3601	Find Drivers with Improved Fuel Efficiency	MySQL	O(nlogn)	O(n)	Medium
3611	Find Overbooked Employees	MySQL	O(m + nlogn)	O(m + n)	Medium
3617	Find Students with Study Spiral Pattern	MySQL	O(nlogn)	O(n)	Hard		Window Function
3626	Find Stores with Inventory Imbalance	MySQL	O(n^2 logn)*	O(n^2)	Medium
3642	Find Books with Polarized Opinions	MySQL	O(r + nlogn)	O(r + n)	Easy
3657	Find Loyal Customers	MySQL	O(nlogn)	O(n)	Medium
3673	Find Zombie Sessions	MySQL	O(nlogn)	O(n)	Hard
3705	Find Golden Hour Customers	MySQL	O(nlogn)	O(n)	Medium
3716	Find Churn Risk Customers	MySQL	O(nlogn)	O(n)	Medium		Window Function
3764	Most Common Course Pairs	MySQL	O(nlogn)	O(n)	Hard		Window Function
3793	Find Users with High Token Usage	MySQL	O(nlogn)	O(n)	Easy
3808	Find Emotionally Consistent Users	MySQL	O(nlogn)	O(n)	Medium		Window Function
3832	Find Users with Persistent Behavior Patterns	MySQL	O(nlogn)	O(n)	Hard		Window Function

⬆️ Back to Top

PD

#	Title	Solution	Time	Space	Difficulty	Tag	Note

⬆️ Back to Top

ton-blockchain/ton

Main TON monorepo

Reference implementation of TON Node and tools

Main TON monorepo, which includes the code of the node/validator, lite-client, tonlib, FunC compiler, etc.

The Open Network

The Open Network (TON) is a fast, secure, scalable blockchain focused on handling millions of transactions per second (TPS) with the goal of reaching hundreds of millions of blockchain users.

To learn more about different aspects of TON blockchain and its underlying ecosystem check documentation
To run node, validator or lite-server check Participate section
To develop decentralised apps check Tutorials, FunC docs and DApp tutorials
To work on TON check wallets, explorers, DEXes and utilities
To interact with TON check APIs

Updates flow

master branch - mainnet is running on this stable branch.

Only emergency updates, urgent updates, or updates that do not affect the main codebase (GitHub workflows / docker images / documentation) are committed directly to this branch.
testnet branch - testnet is running on this branch. The branch contains a set of new updates. After testing, the testnet branch is merged into the master branch and then a new set of updates is added to testnet branch.
backlog - other branches that are candidates to getting into the testnet branch in the next iteration.

Usually, the response to your pull request will indicate which section it falls into.

"Soft" Pull Request rules

Thou shall not merge your own PRs, at least one person should review the PR and merge it (4-eyes rule)
Thou shall make sure that workflows are cleanly completed for your PR before considering merge

Build TON blockchain

Ubuntu 22.04, 24.04 (x86-64, aarch64)

Install additional system libraries

  sudo apt-get update
  sudo apt-get install -y build-essential git cmake ninja-build

  wget https://apt.llvm.org/llvm.sh
  chmod +x llvm.sh
  sudo ./llvm.sh 21 clang

Compile TON binaries

  cp assembly/native/build-ubuntu-shared.sh .
  chmod +x build-ubuntu-shared.sh
  ./build-ubuntu-shared.sh

MacOS 11, 12 (x86-64, aarch64)

  cp assembly/native/build-macos-shared.sh .
  chmod +x build-macos-shared.sh
  ./build-macos-shared.sh

Windows 10, 11, Server (x86-64)

You need to install MS Visual Studio 2022 first. Go to https://www.visualstudio.com/downloads/ and download MS Visual Studio 2022 Community.

Launch installer and select Desktop development with C++. After installation, also make sure that cmake is globally available by adding C:\Program Files\Microsoft Visual Studio\2022\Community\Common7\IDE\CommonExtensions\Microsoft\CMake\CMake\bin to the system PATH (adjust the path per your needs).

Open an elevated (Run as Administrator) x86-64 Native Tools Command Prompt for VS 2022, go to the root folder, and execute:

  copy assembly\native\build-windows-2022.bat .
  build-windows-2022.bat

MSYS2 MinGW64 (x86-64)

Execute from MinGW64 shell

  cp assembly/msys2/build-mingw64.sh .
  chmod +x build-mingw64.sh
  ./build-mingw64.sh -a

As a result, you will get fully statically compiled TON windows binaries.

MSYS2 UCRT64 (x86-64)

Execute from ucrt64 shell

  cp assembly/msys2/build-ucrt64.sh .
  chmod +x build-ucrt64.sh
  ./build-ucrt64.sh -a

As a result, you will get fully statically compiled TON windows binaries.

Building TON to WebAssembly

Install additional system libraries on Ubuntu

  sudo apt-get update
  sudo apt-get install -y build-essential git cmake ninja-build

  wget https://apt.llvm.org/llvm.sh
  chmod +x llvm.sh
  sudo ./llvm.sh 21 clang

Compile TON binaries with emscripten

  cd assembly/wasm
  chmod +x fift-func-wasm-build-ubuntu.sh
  ./fift-func-wasm-build-ubuntu.sh

Building TON tonlib library for Android (arm64-v8a, armeabi-v7a, x86, x86-64)

Install additional system libraries on Ubuntu

  sudo apt-get update
  sudo apt-get install -y build-essential git cmake ninja-build automake libtool texinfo autoconf libgflags-dev \
  libreadline-dev pkg-config libgsl-dev python3 python3-dev libtool autoconf

Compile TON tonlib library

  cp assembly/android/build-android-tonlib.sh .
  chmod +x build-android-tonlib.sh
  ./build-android-tonlib.sh

TON portable binaries

Linux portable binaries are wrapped into AppImages, at the same time MacOS portable binaries are statically linked executables. Linux and MacOS binaries are available for both x86-64 and arm64 architectures.

Running tests

Tests are executed by running ctest in the build directory. See doc/Tests.md for more information.

microsoft/WSL

Windows Subsystem for Linux

Welcome to the Windows Subsystem for Linux (WSL) repository

Learn more about WSL | Downloads & Release notes | Contributing to WSL

About

Windows Subsystem for Linux (WSL) is a powerful way for you to run your Linux command-line tools, utilities and applications, all unmodified and directly on Windows without the overhead of a traditional virtual machine or dual boot setup.

You can install WSL right away by running this command inside of your Windows command line:

wsl --install

You can learn more about best practices for setup, overviews of WSL and more at our WSL documentation page.

Related repositories

WSL also has related open source repositories:

microsoft/WSL2-Linux-Kernel - The Linux kernel shipped with WSL
microsoft/WSLg - Support for Linux GUI apps in WSL
microsoftdocs/wsl - WSL documentation at aka.ms/wsldocs

Contributing

This project welcomes contributions of all types, including coding features / bug fixes, documentation fixes, design proposals and more.

We ask that before you start working on a contribution, please read our Contributor's Guide.

For guidance on developing for WSL, please read the developer docs for instructions on how to build WSL from source and details on its architecture.

Code of Conduct

This project has adopted the Microsoft Open Source Code of Conduct

Trademarks

This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft trademarks or logos is subject to and must follow Microsoft’s Trademark & Brand Guidelines. Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship. Any use of third-party trademarks or logos are subject to those third-party’s policies.

Privacy and telemetry

The application logs basic diagnostic data (telemetry). For more information on privacy and what we collect, see our data and privacy documentation.

The software may collect information about you and your use of the software and send it to Microsoft. Microsoft may use this information to provide services and improve our products and services. You may turn off the telemetry as described in the repository. There are also some features in the software that may enable you and Microsoft to collect data from users of your applications. If you use these features, you must comply with applicable law, including providing appropriate notices to users of your applications together with a copy of Microsoft’s privacy statement. Our privacy statement is located at https://go.microsoft.com/fwlink/?LinkID=824704. You can learn more about data collection and use in the help documentation and our privacy statement. Your use of the software operates as your consent to these practices.

NVIDIA/cutlass

CUDA Templates and Python DSLs for High-Performance Linear Algebra

Overview

CUTLASS 4.5.0

CUTLASS 4.5.0 - May 2026

CUTLASS is a collection of abstractions for implementing high-performance matrix-matrix multiplication (GEMM) and related computations at all levels and scales within CUDA. It incorporates strategies for hierarchical decomposition and data movement. CUTLASS decomposes these "moving parts" into reusable, modular software components and abstractions.

Primitives for different levels of a conceptual parallelization hierarchy can be specialized and tuned via custom tiling sizes, data types, and other algorithmic policy. The resulting flexibility simplifies their use as building blocks within custom kernels and applications.

CUTLASS has been providing CUDA C++ template abstractions for high-performance linear algebra since 2017 and these abstractions provide extensive support for a wide range of computations including mixed-precision computations, specialized data-movement (async copy) and multiply-accumulate abstractions for FP64, FP32, TF32, FP16, BF16, FP32 emulation via tensor core instruction, 8b floating point types (e5m2 and e4m3), block scaled data types (NVIDIA NVFP4 and OCP standard MXFP4, MXFP6, MXFP8), narrow integer types (4 and 8b signed and unsigned integers), and binary 1b data types (where architectures allow for the native support of such data types) across NVIDIA's Volta, Turing, Ampere, Ada, Hopper, and Blackwell architectures.

To this rich ecosystem of C++ based kernel programming abstractions, CUTLASS 4 adds CUTLASS DSLs. These are Python native interfaces for writing high-performance CUDA kernels based on core CUTLASS and CuTe concepts without any performance compromises. This allows for a much smoother learning curve, orders of magnitude faster compile times, native integration with DL frameworks without writing glue code, and much more intuitive metaprogramming that does not require deep C++ expertise.

Overall we envision CUTLASS DSLs as a family of domain-specific languages (DSLs). With the release of 4.0, we are releasing the first of these in CuTe DSL. This is a low level programming model that is fully consistent with CuTe C++ abstractions — exposing core concepts such as layouts, tensors, hardware atoms, and full control over the hardware thread and data hierarchy.

CuTe DSL demonstrates optimal matrix multiply and other linear algebra operations targeting the programmable, high-throughput Tensor Cores implemented by NVIDIA's Ampere, Hopper, and Blackwell architectures.

We believe it will become an indispensable tool for students, researchers, and performance engineers alike — flattening the learning curve of GPU programming, rapidly prototyping kernel designs, and bringing optimized solutions into production.

CuTe DSL is currently in public beta and will graduate out of beta by end of summer 2025.

To get started quickly - please refer :

What's New in CUTLASS 4.5

CuTe DSL

New features
- New Block API block_copy() to simplify TMA and S2T copy. Users can ignore detail about multicast and 2CTA partition for TMA by block_copy() and need not to invoke tma_partition(). And users can remove bulk of S2T initialization to simplify S2T copy.
- MXF8F6F4 mixed precision support
  - BlockScaled MMA now supports MXF8MXF4 or MXF8MXF6
- Block Scaled MMA for SM120 now works on Spark
- EFC broadcast semantics support
  - EFC epilogue functions can now broadcast and remap tensor modes via C.remap_modes[:, 0, 1] subscript syntax (where : marks a broadcast dimension and integers select source mode indices). Covers scalar broadcast, row/column broadcast, and arbitrary mode permutations (e.g. transpose). The PyTorch reference evaluator mirrors the same transformations.
- Initial linter support: Improved type hints on CuTe DSL APIs to support static type checkers like MyPy
- dataclasses.dataclass is now supported for JIT compilaton and cute.compile for both plain and tvm-ffi path
- cute.copy now supports user specified loop unrolling
Bug fixing and improvements
- Improved source code correlation for profiling/debugging
- Fixed an aarch64 segfault issue with tvm-ffi
- Re-organization for CuTe DSL examples/tutorials for better discoverability
More examples of authorizing peak-performance kernels
- MOE examles
  - A new style of grouped-gemm that aligns to torch's grouped_mm and scaled_groued_mm interface.
  - Expert-wise tensormap descriptor setup by a cheap helper kernel (~2us) to avoid long latency in tile switching, kernel structure is much more closer to a normal GEMM.
  - Compared to torch_210_cu13, very few problem has worse perf in B200.
    - mxfp8_2dx3d: avg 1.29 speedup;
    - mxfp8_2dx2d: avg 1.41 speedup;
      - nvfp4_2dx3d: avg 1.11 speedup;
    - nvfp4_2dx2d: avg 1.12 speedup (worst case 0.98)
    - bf16_2dx3d: avg 1.15 speedup (worst case 0.98)
    - bf16_2dx2d: avg 1.17 speedup (worst case 0.96)
    - Note: The perf is measured from torch profiler, this impl includes the helper kernel + main kernel, while torch's includes its setup kernel and cutlass_cpp main kernel.
API changes
- ab_dtype is deprecated in make_trivial_tiled_mma and make_blockscaled_trivial_tiled_mma from blackwell_helpers.py. Please specify a_dtype and b_dtype separately instead.

CUTLASS C++

Add 2SM MMA instruction support to mixed TMA+CpAsync SM100 vanilla GEMM kernels.
- Mixed TMA+CpAsync can now accept static, but non trivial cluster shapes.
- Uses TMA multicast for A tile when using non-trivial cluster size along N mode.
- Uses an additional barrier (mma_trampoline_barrier) to track cp.async arrivals in both CTAs.
- Changes included in example 92.
Add support for 128x32xK and 128x64xK tile sizes for SM120 blockscaled MMA collective builders, yielding up to 30% performance improvement on Blackwell SM121 related kernels.
Add static load to tensor memory support, included in example 77.
Use 64-bit adds for SM100 MMA descriptor offsets and reduce move instructions for improved code generation.
Add example 95 to support green context SM partition
- Enables launching GEMM on stream with partial SM allocation.
Add Snake activation functor for EVT.
Fix some kernel issues:
- Fix l2_capacity=0 handling in Blackwell SM100/SM120 kernel templates
- Fix CUTLASS clang build issues
- Fix atomicCAS read-modify-write loop in ConstSubbyteReference
- Replace __nv_atomic_load_n with volatile for CUDA 11.4 compatibility in subbyte reference
- Remove PipelineStorage shadowing in SM100 complex epilogue
- Fix build issue in SM90 epilogue fusion visitor TMA warpspecialized
Fix some profiler issues:
- Add missing reference kernels for blockwise GEMM profiler.

Note: CUTLASS 4.x builds are known to be down on Windows platforms for all CUDA toolkits. CUTLASS team is working on a fix.

See the CHANGELOG for details of all past releases and updates.

Performance

CUTLASS primitives are very efficient. When used to construct device-wide GEMM kernels, they exhibit nearly optimal utilization of peak theoretical throughput. The figure below shows CUTLASS 3.8's performance as a % of theoretical peak utilization on various input and output data types when run on NVIDIA Blackwell SM100 architecture GPU.

The two figures below show the continual CUTLASS performance improvements on an NVIDIA H100 (NVIDIA Hopper architecture) since CUTLASS 3.1. CUTLASS 3.5.1 was compiled with the CUDA 12.5u1 Toolkit. Tensor Core operations are implemented using CUDA's mma and wgmma instructions.

CuTe

CUTLASS 3.0 introduced a new core library, CuTe, to describe and manipulate tensors of threads and data. CuTe is a collection of C++ CUDA template abstractions for defining and operating on hierarchically multidimensional layouts of threads and data. CuTe provides Layout and Tensor objects that compactly package the type, shape, memory space, and layout of data, while performing the complicated indexing for the user. This lets programmers focus on the logical descriptions of their algorithms while CuTe does the mechanical bookkeeping for them. With these tools, we can quickly design, implement, and modify all dense linear algebra operations.

The core abstractions of CuTe are hierarchically multidimensional layouts which can be composed with data arrays to represent tensors. The representation of layouts is powerful enough to represent nearly everything we need to implement efficient dense linear algebra. Layouts can also be combined and manipulated via functional composition, on which we build a large set of common operations such as tiling and partitioning.

CUTLASS 3.0 and beyond adopts CuTe throughout the GEMM hierarchy in its templates. This greatly simplifies the design and improves code composability and readability. More documentation specific to CuTe can be found in its dedicated documentation directory.

Compatibility

Minimum requirements:

Architecture: Volta (compute capability 7.0)
Compiler: Must support at least C++17
CUDA Toolkit version: 11.4

CUTLASS requires a C++17 host compiler and performs best when built with the CUDA 12.8 Toolkit. It is also compatible with CUDA 11.4, CUDA 11.5, CUDA 11.6, CUDA 11.7, CUDA 11.8, and all other CUDA 12.x versions.

Operating Systems

We have tested the following environments.

Operating System	Compiler
Ubuntu 18.04	GCC 7.5.0
Ubuntu 20.04	GCC 10.3.0
Ubuntu 22.04	GCC 11.2.0

Note: GCC 8.5.0 has known regressions regarding fold expressions and overloaded operators. Using GCC 7.5.0 or (preferred) GCC >= 9 is recommended.

Note: CUTLASS 3.x builds are known to be down on Windows platforms for all CUDA toolkits. CUTLASS team is working on a fix.

Hardware

CUTLASS runs successfully on the following NVIDIA GPUs, and it is expected to be efficient on Volta, Turing, Ampere, Ada, and Hopper architecture based NVIDIA GPUs.

GPU	CUDA Compute Capability	Minimum CUDA Toolkit Required by CUTLASS-3
NVIDIA V100 Tensor Core GPU	7.0	11.4
NVIDIA TitanV	7.0	11.4
NVIDIA GeForce RTX 20x0 series	7.5	11.4
NVIDIA T4	7.5	11.4
NVIDIA A100 Tensor Core GPU	8.0	11.4
NVIDIA A10	8.6	11.4
NVIDIA GeForce RTX 30x0 series	8.6	11.4
NVIDIA GeForce RTX 40x0 series	8.9	11.8
NVIDIA L40	8.9	11.8
NVIDIA H100 Tensor Core GPU	9.0	11.8
NVIDIA H200 Tensor Core GPU	9.0	11.8
NVIDIA B200 Tensor Core GPU	10.0	12.8
NVIDIA B300 Tensor Core GPU	10.3	13.0
NVIDIA DRIVE Thor	11.0	13.0
NVIDIA GeForce RTX 50x0 series	12.0	12.8
NVIDIA DGX Spark	12.1	13.0

Target Architecture

In general, PTX code generated for one target architecture can be run on future architectures (i.e., it is forward compatible). However, CUDA 12.0 introduced the concept of "architecture-accelerated features" whose PTX does not have forward compatibility guarantees. Several Hopper and Blackwell PTX instructions fall under this category of architecture-accelerated features, and thus require a sm_90a or sm100a target architecture (note the "a" appended). For more details on this and other architecture-accelerated instructions, please refer to the CUDA Documentation.

The target architecture information is passed on to CUTLASS via the cmake flag CUTLASS_NVCC_ARCHS. In order to maximize performance on Hopper GH100, users are required to build CUTLASS with 90a as the target architecture. If a user accidentally builds a kernel which uses SM90a features (e.g. Hopper Tensor Core Instructions), using the SM90 target (note the lack of "a"), with either CUDA Toolkit 12 or 11.8, the kernel is expected to fail with a runtime error.

cmake .. -DCUTLASS_NVCC_ARCHS="90a"

cmake .. -DCUTLASS_NVCC_ARCHS="100a"

Note: The NVIDIA Blackwell SM100 architecture used in the datacenter products has a different compute capability than the one underpinning NVIDIA Blackwell GeForce RTX 50 series GPUs (SM120). As a result, kernels compiled for Blackwell SM100 architecture with arch conditional features (using sm100a) are not compatible with RTX 50 series GPUs.

Please refer to the functionality documentation for details on which kernels require which target architectures.

Documentation

CUTLASS is described in the following documents and the accompanying Doxygen documentation.

Quick Start Guide - basics of building and running CUTLASS
Functionality - summarizes functionality available in CUTLASS
Efficient GEMM in CUDA - describes how GEMM kernels may be implemented efficiently in CUDA
CUTLASS 3.x Design - describes the CUTLASS 3.x design, its benefits, and how CuTe enables us to write much more composable components
GEMM API 3.x - describes the CUTLASS 3.x GEMM model and C++ template concepts
GEMM API 2.x - describes the CUTLASS 2.x GEMM model and C++ template concepts
Implicit GEMM Convolution - describes 2-D and 3-D convolution in CUTLASS
Code Organization - describes the organization and contents of the CUTLASS project
Terminology - describes terms used in the code
Programming Guidelines - guidelines for writing efficient modern CUDA C++
Fundamental types - describes basic C++ classes used in CUTLASS to represent numeric quantities and arrays
Layouts - describes layouts of matrices and tensors in memory
Tile Iterators - describes C++ concepts for iterating over tiles of matrices in memory
CUTLASS Profiler - command-line driven profiling application
CUTLASS Utilities - additional templates used to facilitate rapid development
Dependent kernel launch - describes a new feature in Hopper which allows overlapping dependent kernels in the same stream, and how it is used in CUTLASS.

Resources

We have also described the structure of an efficient GEMM in our talk at the GPU Technology Conference 2018.

Building CUTLASS

CUTLASS is a header-only template library and does not need to be built to be used by other projects. Client applications should target CUTLASS's include/ directory in their include paths.

CUTLASS unit tests, examples, and utilities can be build with CMake. The minimum version of CMake is given in the Quickstart guide. Make sure the CUDACXX environment variable points to NVCC in the CUDA Toolkit installed on your system.

$ export CUDACXX=${CUDA_INSTALL_PATH}/bin/nvcc

Create a build directory within the CUTLASS project, then run CMake. By default CUTLASS will build kernels for CUDA architecture versions 5.0, 6.0, 6.1, 7.0, 7.5, 8.0, 8.6, 8.9, and 9.0. To reduce compile time you can specify the architectures to build CUTLASS for by changing the CMake configuration setting CUTLASS_NVCC_ARCHS.

$ mkdir build && cd build

$ cmake .. -DCUTLASS_NVCC_ARCHS=80               # compiles for NVIDIA's Ampere Architecture

From the build/ directory, compile and run the CUTLASS unit tests by building the target test_unit with make.

The unit tests are organized as several binaries mirroring the top-level namespaces of CUTLASS, and they may be executed in parallel via make's -j command line argument.

$ make test_unit -j
...
...
...
[----------] Global test environment tear-down
[==========] 946 tests from 57 test cases ran. (10812 ms total)
[  PASSED  ] 946 tests.

All tests should pass on supported platforms, though the exact number of tests may vary over time.

Project Structure

CUTLASS is arranged as a header-only library along with Utilities, Tools, Examples, and unit tests. Doxygen documentation provides a complete list of files, classes, and template concepts defined in the CUTLASS project.

A detailed explanation of the source code organization may be found in the CUTLASS documentation, but several main components are summarized below.

CUTLASS Template Library

include/                     # client applications should target this directory in their build's include paths

  cutlass/                   # CUDA Templates for Linear Algebra Subroutines and Solvers - headers only

    arch/                    # direct exposure of architecture features (including instruction-level GEMMs)

    conv/                    # code specialized for convolution

    epilogue/                # code specialized for the epilogue of gemm/convolution

    gemm/                    # code specialized for general matrix product computations

    layout/                  # layout definitions for matrices, tensors, and other mathematical objects in memory

    platform/                # CUDA-capable Standard Library components

    reduction/               # bandwidth-limited reduction kernels that do not fit the "gemm" model

    thread/                  # simt code that can be performed within a CUDA thread

    transform/               # code specialized for layout, type, and domain transformations

    *                        # core vocabulary types, containers, and basic numeric operations

  cute/                      # CuTe Layout, layout algebra, MMA/Copy atoms, tiled MMA/Copy

    algorithm/               # Definitions of core operations such as copy, gemm, and operations on cute::tuples

    arch/                    # Bare bones PTX wrapper structs for copy and math instructions

    atom/                    # Meta-information either link to or built from arch/ operators

      mma_atom.hpp           # cute::Mma_Atom and cute::TiledMma

      copy_atom.hpp          # cute::Copy_Atom and cute::TiledCopy

      *sm*.hpp               # Arch specific meta-information for copy and math operations

    *                        # Core library types such as Shape, Stride, Layout, Tensor, and associated operations

CUTLASS SDK Examples

CUTLASS SDK examples apply CUTLASS templates to implement basic computations.

Tools

tools/
  library/                   # CUTLASS Instance Library - contains instantiations of all supported CUTLASS templates
    include/
      cutlass/
        library/

  profiler/                  # CUTLASS Profiler         - command-line utility for executing operations in the
                             #                            CUTLASS Library

  util/                      # CUTLASS Utilities        - contains numerous helper classes for
    include/                 #                            managing tensors in device memory, reference
      cutlass/               #                            implementations for GEMM, random initialization
        util/                #                            of tensors, and I/O.

Test

The test/unit/ directory consist of unit tests implemented with Google Test that demonstrate basic usage of Core API components and complete tests of the CUTLASS GEMM computations.

Instructions for building and running the Unit tests are described in the Quickstart guide.

Performance Profiling

The tools/profiler/ directory contains a command-line utility for launching each of the GEMM kernels. It can be built as follows:

$ make cutlass_profiler -j16

Building all GEMM and Convolution kernels (long build times)

By default, only one tile size is instantiated for each data type, math instruction, and layout. To instantiate all, set the following environment variable when running CMake from an empty build/ directory. Beware, this results in tens of thousands of kernels and long build times. This would also result in a large binary size and on some platforms linker to fail on building the library. Therefore, it's highly recommended to generate only a subset of kernels as demonstrated in the sub-section below.

$ cmake .. -DCUTLASS_NVCC_ARCHS=90a -DCUTLASS_LIBRARY_KERNELS=all
...
$ make cutlass_profiler -j16

Building a subset of GEMM and Convolution kernels (reduced build times)

To compile strictly one kernel or a small set of kernels, a comma-delimited list of kernel names with wildcard characters may be used to reduce the set of kernels. The following examples show building exactly one or a subset of kernels for NVIDIA Ampere and Turing architecture:

Building a subset Tensor Core GEMM kernels

To compile a subset of Tensor Core GEMM kernels with FP32 accumulation and FP16 input targeting NVIDIA Ampere and Turing architecture, use the below cmake command line:

$ cmake .. -DCUTLASS_NVCC_ARCHS='75;80' -DCUTLASS_LIBRARY_KERNELS=cutlass_tensorop_s*gemm_f16_*_nt_align8
...
$ make cutlass_profiler -j16

Example command line for profiling a subset of Tensor Core GEMM kernels is as follows:

./tools/profiler/cutlass_profiler --kernels=cutlass_tensorop_s*gemm_f16_*_nt_align8 --m=3456 --n=4096 --k=4096

...
=============================
  Problem ID: 1

        Provider: CUTLASS
   OperationKind: gemm
       Operation: cutlass_tensorop_s1688gemm_f16_256x128_32x2_nt_align8

          Status: Success
    Verification: ON
     Disposition: Passed

reference_device: Passed
          cuBLAS: Passed

       Arguments: --gemm_kind=universal --m=3456 --n=4096 --k=4096 --A=f16:column --B=f16:row --C=f32:column --alpha=1  \
                  --beta=0 --split_k_slices=1 --batch_count=1 --op_class=tensorop --accum=f32 --cta_m=256 --cta_n=128  \
                  --cta_k=32 --stages=2 --warps_m=4 --warps_n=2 --warps_k=1 --inst_m=16 --inst_n=8 --inst_k=8 --min_cc=75  \
                  --max_cc=1024

           Bytes: 118489088  bytes
           FLOPs: 115992428544  flops

         Runtime: 1.55948  ms
          Memory: 70.7616 GiB/s

            Math: 74378.8 GFLOP/s



=============================
...

Building one CUDA Core GEMM kernel

To compile one SGEMM kernel targeting NVIDIA Ampere and Turing architecture, use the below cmake command line:

$ cmake .. -DCUTLASS_NVCC_ARCHS='75;80' -DCUTLASS_LIBRARY_KERNELS=cutlass_simt_sgemm_128x128_8x2_nn_align1
...
$ make cutlass_profiler -j16

Example command line for profiling single SGEMM CUDA kernel is as follows:

$ ./tools/profiler/cutlass_profiler --kernels=sgemm --m=3456 --n=4096 --k=4096

=============================
  Problem ID: 1

        Provider: CUTLASS
   OperationKind: gemm
       Operation: cutlass_simt_sgemm_128x128_8x2_nn_align1

          Status: Success
    Verification: ON
     Disposition: Passed

          cuBLAS: Passed

       Arguments: --m=3456 --n=4096 --k=4096 --A=f32:column --B=f32:column --C=f32:column --alpha=1 --beta=0 --split_k_slices=1  \
                  --batch_count=1 --op_class=simt --accum=f32 --cta_m=128 --cta_n=128 --cta_k=8 --stages=2 --warps_m=4  \
                  --warps_n=2 --warps_k=1 --inst_m=1 --inst_n=1 --inst_k=1 --min_cc=50 --max_cc=1024

           Bytes: 180355072  bytes
           FLOPs: 115992428544  flops

         Runtime: 6.73655  ms
          Memory: 24.934 GiB/s

            Math: 17218.4 GFLOP/s

=============================

Building a subset of Tensor Core Convolution kernels

To compile a subset of Tensor core convolution kernels implementing forward propagation (fprop) with FP32 accumulation and FP16 input targeting NVIDIA Ampere and Turing architecture, use the below cmake command line:

$ cmake .. -DCUTLASS_NVCC_ARCHS='75;80' -DCUTLASS_LIBRARY_KERNELS=cutlass_tensorop_s*fprop_optimized_f16
...
$ make cutlass_profiler -j16

Example command line for profiling a subset of Tensor Core convolution kernels is as follows:

$ ./tools/profiler/cutlass_profiler --kernels=cutlass_tensorop_s*fprop_optimized_f16 --n=8 --h=224 --w=224 --c=128 --k=128 --r=3 --s=3

...
=============================
  Problem ID: 1

        Provider: CUTLASS
   OperationKind: conv2d
       Operation: cutlass_tensorop_s16816fprop_optimized_f16_128x128_32x5_nhwc

          Status: Success
    Verification: ON
     Disposition: Passed

reference_device: Passed

       Arguments: --conv_kind=fprop --n=8 --h=224 --w=224 --c=128 --k=128 --r=3 --s=3 --p=224 --q=224 --pad_h=1 --pad_w=1  \
                  --stride_h=1 --stride_w=1 --dilation_h=1 --dilation_w=1 --Activation=f16:nhwc --Filter=f16:nhwc --Output=f32:nhwc  \
                  --conv_mode=cross --iterator_algorithm=optimized --alpha=1 --beta=0 --split_k_mode=serial --split_k_slices=1  \
                  --eq_gemm_provider=none --op_class=tensorop --accum=f32 --cta_m=128 --cta_n=128 --cta_k=32 --stages=5  \
                  --warps_m=2 --warps_n=2 --warps_k=1 --inst_m=16 --inst_n=8 --inst_k=16 --min_cc=80 --max_cc=1024

           Bytes: 1130659840  bytes
           FLOPs: 118482796544  flops

         Runtime: 0.711496  ms
          Memory: 1479.99 GiB/s

            Math: 166526 GFLOP/s

=============================
...

Building one Convolution CUDA kernel

To compile and run one CUDA Core convolution kernel implementing forward propagation (fprop) with F32 accumulation and FP32 input targeting NVIDIA Ampere and Turing architecture, use the below cmake command line:

$ cmake .. -DCUTLASS_NVCC_ARCHS='75;80' -DCUTLASS_LIBRARY_KERNELS=cutlass_simt_sfprop_optimized_128x128_8x2_nhwc
...
$ make cutlass_profiler -j16

Example command line for profiling one CUDA Core convolution kernel:

$ ./tools/profiler/cutlass_profiler --kernels=cutlass_simt_sfprop_optimized_128x128_8x2_nhwc --n=8 --h=224 --w=224 --c=128 --k=128 --r=3 --s=3


=============================
  Problem ID: 1

        Provider: CUTLASS
   OperationKind: conv2d
       Operation: cutlass_simt_sfprop_optimized_128x128_8x2_nhwc

          Status: Success
    Verification: ON
     Disposition: Passed

reference_device: Passed

       Arguments: --conv_kind=fprop --n=8 --h=224 --w=224 --c=128 --k=128 --r=3 --s=3 --p=224 --q=224 --pad_h=1 --pad_w=1  \
                  --stride_h=1 --stride_w=1 --dilation_h=1 --dilation_w=1 --Activation=f32:nhwc --Filter=f32:nhwc --Output=f32:nhwc  \
                  --conv_mode=cross --iterator_algorithm=optimized --alpha=1 --beta=0 --split_k_mode=serial --split_k_slices=1  \
                  --eq_gemm_provider=none --op_class=simt --accum=f32 --cta_m=128 --cta_n=128 --cta_k=8 --stages=2 --warps_m=4  \
                  --warps_n=2 --warps_k=1 --inst_m=1 --inst_n=1 --inst_k=1 --min_cc=50 --max_cc=1024

           Bytes: 2055798784  bytes
           FLOPs: 118482796544  flops

         Runtime: 7.34266  ms
          Memory: 260.752 GiB/s

            Math: 16136.2 GFLOP/s


=============================

More Details on Compiling CUTLASS Kernels and CUTLASS Profiler

Please follow the links for more CMake examples on selectively compiling CUTLASS kernels:
- GEMM CMake Examples
- Implicit GEMM convolution CMake Examples
Further details about the CUTLASS Profiler are described here.

About

CUTLASS is released by NVIDIA Corporation as Open Source software under the 3-clause "New" BSD license.

Contributors

The official list of CUTLASS developers and contributors is available here: CONTRIBUTORS.

Copyright

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:

  1. Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.

  2. Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.

  3. Neither the name of the copyright holder nor the names of its
  contributors may be used to endorse or promote products derived from
  this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

ztxz16/fastllm

fastllm是后端无依赖的高性能大模型推理库。同时支持张量并行推理稠密模型和混合模式推理MOE模型，任意10G以上显卡即可推理满血DeepSeek。双路9004/9005服务器+单显卡部署DeepSeek满血满精度原版模型，单并发20tps；INT4量化模型单并发30tps，多并发可达60+。

fastllm

引用说明

本项目参考了许多开源项目的代码和相关文章，具体请参考参考代码和文章

介绍

fastllm是c++实现自有算子替代Pytorch的高性能全功能大模型推理库，可以推理Qwen, Llama, Phi等稠密模型，以及DeepSeek, Qwen-moe等moe模型

具有优良的兼容性，支持M40, K80到5090全系列N卡，支持MI50，7900等A卡，支持天数，沐曦等国产卡，支持ThinkForce NPU推理
支持任意显卡的FP8推理
任意显卡只需要显存 > 10G就可以支持单卡推理满血DeepSeek R1 671B模型
双路9004/9005服务器 + 单显卡部署DeepSeek R1 671B - FP8原版模型，单并发速度可达20左右，部署INT4模型单并发速度可达30左右，最高并发速度可达60+

部署交流QQ群：831641348

微信

用户交流群（使用、部署等问题）：
社区开发群（参与贡献与开发讨论）：

新功能速览

Fastllm目前支持DeepSeek-V4模型了
Fastllm目前支持导出通用动态量化模型了！参考动态量化说明
Fastllm目前可以支持部分GGUF模型的读取了！需要注意，目前需要使用--ori参数指定源模型配置文件夹，请阅读使用指南

亮点功能

🚀 安装使用简单方便，一条命令就能成功安装，一条命令就能成功运行。
🚀 支持CPU + GPU混合推理MOE大参数模型（单显卡即可推理DEEPSEEK 671B）。
🚀 使用C++实现自有底层算子，不依赖PyTorch。
🚀 兼容性好，PIP安装支持可以支持到P100、MI50等老卡，源码安装支持更多设备。
🚀 支持多卡张量并行推理，支持3、5、7等奇数张卡。
🚀 支持GPU + CPU混合张量并行推理
🚀 支持CPU和显卡实现FP8运算，老设备也可以运行
🚀 支持多CPU加速，且只占用1份内存
🚀 支持ROCM，AMD GPU；支持天数，沐曦，燧原；支持华为昇腾。
🚀 支持动态Batch，流式输出；前后端分离设计，可跨平台移植，可在安卓上直接编译。
🚀 支持Python自定义模型结构

快速开始

安装

pip安装支持Nvidia GPU和AMD GPU，其余GPU请使用源码安装
pip安装速度慢时，可使用镜像加速

pip config set global.index-url https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple

Linux系统 + Nvidia GPU:

pip install ftllm -U

Linux系统 + AMD GPU:

由于目前PyPI限制库大小，安装包中不含ROCM依赖，安装ftllm之前建议先手动安装ROCM 6.3.3 (若已安装ROCM可跳过)

wget wget https://repo.radeon.com/amdgpu-install/6.3.3/ubuntu/jammy/amdgpu-install_6.3.60303-1_all.deb
apt install ./amdgpu-install_6.3.60303-1_all.deb -y
amdgpu-install --usecase=hiplibsdk,rocm,dkms -y

然后用pip安装，命令如下：

pip install ftllm-rocm -U

Windows系统（仅支持Nvidia GPU）:

第一次安装前需要安装依赖库:

pip install https://www.modelscope.cn/models/huangyuyang/fastllmdepend-windows/resolve/master/ftllmdepend-0.0.0.2-py3-none-win_amd64.whl

然后用pip安装，命令如下：

pip install ftllm -U

Hint

Conda下安装有时候会出现环境错误，如果出现可以尝试在Conda外或使用venv等虚拟环境尝试

（若使用时报错，可参考ftllm报错 )

运行demo程序

可以运行一个较小模型测试安装是否成功, 以Qwen/Qwen3-0.6B模型为例

命令行聊天：

ftllm run Qwen/Qwen3-0.6B

WebUI:

ftllm webui Qwen/Qwen3-0.6B

API Server (OpenAI 风格):

ftllm server Qwen/Qwen3-0.6B

使用指南

1. 如何启动模型

基本的启动命令格式如下：

ftllm run Qwen/Qwen3-0.6B # 启动本地对话
ftllm webui Qwen/Qwen3-0.6B # 启动WebUI
ftllm server Qwen/Qwen3-0.6B # 启动API Server

根据你需要开启的服务，选择相应的命令。以 server 命令为例，格式如下：

ftllm server model

这里的model可以是:

Huggingface上的模型，例如 Qwen/Qwen3-0.6B 代表千问3-0.6B模型
本地模型路径。例如/mnt/Qwen3-0.6B，高速下载模型可以参考模型下载

无论是在线模型还是本地模型，目前支持以下几种格式（均以在线模型举例，可以在Huggingface上搜到对应模型）:

FP16, BF16格式的原始模型，例如Qwen/Qwen3-0.6B
FP8格式的模型，例如Qwen/Qwen3-0.6B-FP8
AWQ格式的模型，例如Qwen/Qwen3-14B-AWQ
Fastllm格式的模型，例如fastllm/DeepSeek-V3-0324-INT4。也可以下载原始模型后通过模型导出中的命令导出
GGUF 格式的模型，需要用--ori参数指定原始模型路径，例如

ftllm server DeepSeek-V3-0324-Q4_K_M-00001-of-00009.gguf --ori DeepSeek-V3

这里的DeepSeek-V3是原始模型文件夹，无需下载权重文件，可以参考如下命令下载：

ftllm download deepseek-ai/DeepSeek-V3 --exclude "*safetensors*"

如果您是第一次使用ftllm，建议直接使用基本的启动命令启动，所有的参数都会自动设置。如果您希望继续调参，请参照下面的参数设置说明

2. 如何设定推理精度

当启动的模型为浮点精度时（BF16, FP16, FP8）时，可以通过以下参数来设置模型的推理精度：

--dtype:
- 描述: 指定模型的数据类型。
- 可选值: int4g int4 int8 fp8 float16 或其他支持的数据类型。
- 示例: --dtype int4
--moe_dtype:
- 描述: 指定模型MOE层的数据类型。
- 可选值: int4g int4 int8 fp8 float16 或其他支持的数据类型。
- 示例: --moe_dtype int4
- 说明: 如果指定的模型不是moe结构的模型，这个参数不会生效

命令示例：

ftllm server Qwen/Qwen3-0.6B --dtype int8 
# 上面的命令会读取原始模型（这个模型是BF16精度），并在线量化为INT8精度推理

ftllm server deepseek-ai/DeepSeek-V3-0324 --dtype fp8 --moe_dtype int4
# 上面的命令会读取原始模型（这个模型是FP8精度），并使用FP8 + INT4的混合精度推理

--dtype_config:
- 描述: 指定动态量化配置文件。
- 说明: 参考动态量化说明

若不设定这些参数，ftllm会使用模型中设定的精度来进行推理

若使用的模型已经是量化好的模型（例如AWQ模型，Fastllm导出的量化模型等），建议不指定这些参数

3. 如何设定运行设备

可以通过以下参数来设定执行推理的设备

--device:
- 描述: 指定模型运行的计算设备。
- 示例: --device cpu, --device cuda
- 常用值说明:
  - cpu 使用cpu推理
  - cuda 使用gpu推理
  - numa 使用多路numa节点加速推理，在多CPU的机器才会有提升。使用numa加速时，强烈建议关闭系统numa平衡。（ubuntu中可使用命令sudo sysctl -w kernel.numa_balancing=0)
  - multicuda 使用多设备张量并行推理
    - 使用多显卡: --device multicuda:0,1
    - 使用多显卡+CPU: --device multicuda:0,cpu
    - 按比例使用多显卡+CPU: --device multicuda:0:4,1:5,cpu:1 (cuda:0计算4/10, cuda:1计算5/10, cpu计算1/10)
- 串行计算: 一些场景下可以指定不同的device串行执行。例如
  - --device "{'cuda:0':3,'cuda:1':2}": 这样3/5的层会运行在cuda:0上，2/5的层会运行在cuda:1上
  - --device "{'multicuda:0,1':3,'cuda:1':2}": 这样3/5的层会使用cuda:0,cuda:1张量并行，2/5的层仅仅运行在cuda:1上
  - 简写: --device cudapp=N 表示N卡均匀串行，例如 --device cudapp=4 等价于 --device "{'cuda:0':1,'cuda:1':1,'cuda:2':1,'cuda:3':1}"
  - 简写: --device cudapp=1:2:3 表示三卡按1:2:3比例串行，等价于 --device "{'cuda:0':1,'cuda:1':2,'cuda:2':3}"
--moe_device:
- 描述: 指定 MOE（Mixture of Experts）层的计算设备。
- 示例: --moe_device cpu, --moe_device numa
- 常用值说明:
  - cpu 使用cpu推理
  - numa 使用多路numa节点加速推理，在多CPU的机器才会有提升
  - cuda 使用gpu推理（MOE层需要大量显存，一般不建议指定为cuda）
- 说明: 一般和device指定为不同的设备实现混合推理，例如 --device cuda --moe_device cpu来实现MOE模型的单卡+CPU混合推理。 --device cuda --moe_device numa 来实现MOE模型的单卡+多NUMA节点加速推理如果指定的模型不是moe结构的模型，这个参数不会生效

若不设定这些参数，会使用默认配置来推理，默认配置如下：

模型类型	device	moe_device
稠密模型	cuda	不生效
MOE模型	cuda	cpu

如果只设置了device没设置moe_device，则moe_device会跟随device

对于发烧友而言，如果想更进一步榨干硬件，可以参考混合推理指南

4. 如何设定运行参数

可以通过下列参数设置运行参数。

需要注意的是，速度和参数设置并不一定正相关，如果对性能要求高，可以多方向尝试一下

-t 或 --threads:
- 描述: 设置使用的CPU线程数。
  - 当device为cpu时，这个参数决定了推理使用的线程数
  - 当device为numa时，推理线程数主要由环境变量FASTLLM_NUMA_THREADS决定，threads参数请设得小一点（推荐设为1）
- 示例: -t 27

例如我们在多CPU设备上用GPU + 多CPU混合部署一个MOE模型fastllm/DeepSeek-V3-0324-INT4，可以尝试这些命令：

export FASTLLM_NUMA_THREADS=27 && ftllm server fastllm/DeepSeek-V3-0324-INT4 --device cuda --moe_device numa -t 1 
# 使用多numa推理，每个numa节点使用27个线程

export FASTLLM_NUMA_THREADS=16 && ftllm server fastllm/DeepSeek-V3-0324-INT4 --device cuda --moe_device numa -t 1 
# 使用多numa推理，每个numa节点使用16个线程

numactl -C 0-31 -m 0 ftllm server fastllm/DeepSeek-V3-0324-INT4 --device cuda --moe_device cpu -t 27 
# 绑定单numa节点，使用CPU推理，使用27线程

不同硬件上，不同参数发挥出的性能有很大不同。一般而言，CPU上使用的线程数不建议超过物理核数

5. 其它参数

--moe_experts:
- 描述: 指定 MOE（Mixture of Experts）层使用的专家数。不设定则根据模型配置设定。减少专家数可以提高推理速度，但可能降低推理准确度
- 示例: --moe_experts 6
--cuda_se:
- 描述: 指定 MOE中的共享专家是否在cuda上执行，默认为true
- 示例: --cuda_se false
--port:
- 描述: 指定服务运行的端口号。
- 示例: --port 8080
--help:
- 描述: 查看模块参数详细信息。
- 示例: ftllm server --help
--version 或 -v:
- 描述: 查看ftllm版本号。
- 示例: ftllm -v
--hide_input:
- 描述: server模式隐藏日志中的请求信息。
- 示例: ftllm server --hide_input
--api_key:
- 描述: server模式设定api_key。
- 示例: ftllm server --api_key xxxxxxxx
--max_token:
- 描述: webui模式指定最大输出。
- 示例: ftllm webui --max_token
--think:
- 描述: 强制思考。
- 示例: ftllm webui --think
--cache_dir:
- 描述: 指定在线Huggingface模型的缓存目录
- 示例: ftllm --cache_dir /mnt
--chat_template:
- 描述: 指定chat_template文件
- 示例: ftllm --chat_template deepseekv31.jinja

工具调用

目前以下模型支持工具调用：

GLM4.5, GLM4.5-AIR
Qwen3-Instruct系列
Qwen3-Coder系列
Kimi-K2
DeepSeekV3.1, 需要指定chat_template, 文件位于本项目example/chat_template/deepseekv31.jinja

模型获取

模型下载

可以使用如下命令将模型下载到本地（使用高速镜像，无需科学上网）

ftllm download deepseek-ai/DeepSeek-R1

模型导出

如果使用量化加载模型（如--dtype int4），那么每次读取模型时会在线量化，读取速度较慢。

ftllm export 是一个用于导出和转换模型权重的工具。它支持将模型权重转换为不同的数据类型。以下是如何使用 ftllm export 的详细说明。

命令格式

ftllm export <模型路径> -o <输出路径> --dtype <数据类型> -t <线程数>

示例命令

ftllm export /mnt/DeepSeek-V3 -o /mnt/DeepSeek-V3-INT4 --dtype int4 -t 16

混合精度

可以通过指定--moe_dtype来实现混合精度，例如

ftllm export /mnt/DeepSeek-V3 -o /mnt/DeepSeek-V3-FP16INT4 --dtype float16 --moe_dtype int4 -t 16

加载导出后的模型

导出后的模型使用方法和原始模型类似，使用导出模型时--dtype参数将被忽略

例如

ftllm run /mnt/DeepSeek-V3-INT4/

支持的模型

如果需要运行更多早期的模型，请参考支持模型列表

源码安装

若pip安装失败或有其它特殊需求，可以用源码编译安装源码安装后如果需要卸载，方法和PIP安装一样

pip uninstall ftllm

建议使用cmake编译，需要提前安装gcc，g++ (建议9.4以上), make, cmake (建议3.23以上)

需要安装numa库，在Ubuntu下的安装命令一般使用：

apt-get install libnuma-dev

如果编译出错，建议使用AI工具帮忙安装环境

GPU编译需要提前安装好CUDA编译环境，建议使用尽可能新的CUDA版本，并安装NCCL包

使用如下命令编译

bash install.sh -DUSE_CUDA=ON -D CMAKE_CUDA_COMPILER=$(which nvcc) # 编译GPU版本
# bash install.sh -DUSE_CUDA=ON -DCUDA_ARCH=89 -D CMAKE_CUDA_COMPILER=$(which nvcc) # 可以指定CUDA架构，如4090使用89架构
# bash install.sh # 仅编译CPU版本

其他平台编译

其他不同平台的编译可参考文档

TFACC平台
 ROCm平台

编译中遇到问题可参考 FAQ文档

参考代码和文章

感谢大佬对开源社区的贡献！如发现未标明的引用代码可在issue中提出

wled/WLED

Control WS2812B and many more types of digital RGB LEDs with an ESP32 over WiFi!

Welcome to WLED! ✨

A fast and feature-rich implementation of an ESP32 and ESP8266 webserver to control NeoPixel (WS2812B, WS2811, SK6812) LEDs or also SPI based chipsets like the WS2801 and APA102!

Originally created by Aircoookie

⚙️ Features

WS2812FX library with more than 100 special effects
FastLED noise effects and 50 palettes
Modern UI with color, effect and segment controls
Segments to set different effects and colors to user defined parts of the LED string
Settings page - configuration via the network
Access Point and station mode - automatic failsafe AP
Up to 10 LED outputs per instance
Support for RGBW strips
Up to 250 user presets to save and load colors/effects easily, supports cycling through them.
Presets can be used to automatically execute API calls
Nightlight function (gradually dims down)
Full OTA software updateability (HTTP + ArduinoOTA), password protectable
Configurable analog clock (Cronixie, 7-segment and EleksTube IPS clock support via usermods)
Configurable Auto Brightness limit for safe operation
Filesystem-based config for easier backup of presets and settings

💡 Supported light control interfaces

WLED app for Android and iOS
JSON and HTTP request APIs
MQTT
E1.31, Art-Net, DDP and TPM2.net
diyHue (Wled is supported by diyHue, including Hue Sync Entertainment under udp. Thanks to Gregory Mallios)
Hyperion
UDP realtime
Alexa voice control (including dimming and color)
Sync to Philips hue lights
Adalight (PC ambilight via serial) and TPM2
Sync color of multiple WLED devices (UDP notifier)
Infrared remotes (24-key RGB, receiver required)
Simple timers/schedules (time from NTP, timezones/DST supported)

📲 Quick start guide and documentation

See the documentation on our official site!

On this page you can find excellent tutorials and tools to help you get your new project up and running!

🖼️ User interface

💾 Compatible hardware

See here!

✌️ Other

Licensed under the EUPL v1.2 license
Credits here! CORS proxy by Corsfix

Join the Discord server to discuss everything about WLED!

Check out the WLED Discourse forum!

You can also send me mails to dev.aircoookie@gmail.com, but please, only do so if you want to talk to me privately.

If WLED really brightens up your day, you can

Disclaimer:

If you are prone to photosensitive epilepsy, we recommended you do not use this software.
If you still want to try, don't use strobe, lighting or noise modes or high effect speed settings.

As per the EUPL license, I assume no liability for any damage to you or any other person or equipment.

dalathegreat/Battery-Emulator

This revolutionary software enables EV battery packs to be easily reused for stationary storage in combination with solar inverters

Battery-Emulator ⚡🔋

What is Battery Emulator?

Many manufacturers sell home battery systems to enable homeowners to store power collected from the grid, or renewable sources, to use at times when electricity demand is higher. However almost all of these home battery systems charge a high cost for every kilowatt hour (kWh) of capacity you buy.

At the same time, EV manufacturers have been putting high capacity battery packs into their cars, with no firm plan for what should happen to those batteries if the car is damaged in a crash, or reaches the end of its life as a vehicle.

Battery Emulator enables EV battery packs to be repurposed for stationary storage. It acts as a translation layer between the EV battery and the home inverter. This makes it extremely cheap and easy to use large EV batteries in a true plug'n'play fashion!

Caution

Working with high voltage is dangerous. Always follow local laws and regulations regarding high voltage work. If you are unsure about the rules in your country, consult a licensed electrician for more information.

Quickstart guide 📜

Pick a supported inverter (solar panels optional) 🌞
Pick a supported battery 🔋
Order the Battery-Emulator compatible hardware 🤖
Follow the installation guidelines section for how to install and commission your battery properly 📓

Installation basics 🪛

Connect your Battery Emulator hardware to your EV battery
Connect your Battery Emulator hardware to your inverter
Wire up high voltage cable between the inverter and the battery
Add a low voltage power supply to your Battery Emulator hardware
Configure any additional requirements to allow Battery Emulator to switch on your EV battery (also referred to as 'closing contactors')
Enjoy a big cheap grid connected battery!

For examples showing wiring, see each battery type's own Wiki page. For instance the Nissan LEAF page

How to install the software 💻

Start by watching this quickstart guide

Open the webinstaller page
Follow the instructions on that page to install the software
After successful installation, connect to the wireless network (Battery-Emulator , password: 123456789)
Go to setup page and configure component selection
(OPTIONAL, connect the board to your home Wifi)
Connect your battery and inverter to the board and you are done! 🔋⚡

Dependencies 📖

This code uses the following excellent libraries:

adafruit/Adafruit_NeoPixel LGPL-3.0 license
ayushsharma82/ElegantOTA AGPL-3.0 license
bblanchon/ArduinoJson MIT-License
eModbus/eModbus MIT-License
ESP32Async/AsyncTCP LGPL-3.0 license
ESP32Async/ESPAsyncWebServer LGPL-3.0 license
pierremolinaro/acan-esp32 MIT-License
pierremolinaro/acan2517FD MIT-License

It is also based on the information found in the following excellent repositories/websites:

Like this project? 💖

Leave a ⭐ If you think this project is useful. Consider hopping onto my Patreon to encourage more open-source projects! As a bonus, you will get access to the Discord server, where we hangout, develop, support, share, discuss etc. all things related to DIY EV storage solutions. See you on the server? 😉

<------ Click here to learn more!

Vita3K/Vita3K

Experimental PlayStation Vita emulator

Vita3K

Introduction

Vita3K is an experimental PlayStation Vita emulator for Windows, Linux, macOS and Android.

Website (information for users)
Wiki (information for developers)
Discord server (recommended)

Compatibility

The emulator currently runs most homebrew programs and commercial games.

Gallery

Persona 4 Golden by Atlus	A Rose in the Twilight by Nippon Ichi Software

Alone with You by Benjamin Rivers	VA-11 HALL-A by Sukeban Games

Fruit Ninja by Halfbrick Studios	Jetpack Joyride by Halfbrick Studios

License

Vita3K is licensed under the GPLv2 license. This is largely dictated by external dependencies, most notably Unicorn.

Downloads

You can download the latest builds from here.

Windows
- Requirements:
  - Microsoft Visual C++ 2015-2022 Redistributable
Linux
- Arch based:
  - vita3k-bin^AUR
  - vita3k-git^AUR
- Requirements:
  - xdg-desktop-portal
Android
- Adreno drivers
Others
- Download Artifact
- Old builds

Building

Please see building.md.

Running

Check our quickstart guide to make sure your computer meets the minimum requirements to run Vita3K.
Don't forget to have your graphics driver up to date and to install the Visual C++ 2015-2022 Redistributable if you are a Windows user.

Bugs and issues

The project is in an early stage, so please be mindful when opening new issues. Expect crashes, glitches, low compatibility and poor performance.

Thanks

Thanks go out to people who offered advice or otherwise made this project possible, such as Davee, korruptor, Rinnegatamante, ScHlAuChi, Simon Kilroy, TheFlow, xerpi, xyz, Yifan Lu and many others.

Donations

Thank you to the supporters and to all those who support us on our ko-fi.

Among them, those who subscribed to the Nibble Tier and upper: j0hnnybrav0, Mored4u, TacoOblivion, Undeadbob and uplush

Note

The purpose of this emulator is not to enable illegal activity. You can dump games from a Vita by using NoNpDrm or FAGDec. You can get homebrew programs from VitaDB.

PlayStation, PlayStation Vita and PlayStation Network are all registered trademarks of Sony Interactive Entertainment Inc. This emulator is not related to or endorsed by Sony, or derived from confidential materials belonging to Sony.

78/xiaozhi-esp32

An MCP-based chatbot | 一个基于MCP的聊天机器人

An MCP-based Chatbot

(English | 中文 | 日本語)

Introduction

👉 Human: Give AI a camera vs AI: Instantly finds out the owner hasn't washed hair for three days【bilibili】

👉 Handcraft your AI girlfriend, beginner's guide【bilibili】

As a voice interaction entry, the XiaoZhi AI chatbot leverages the AI capabilities of large models like Qwen / DeepSeek, and achieves multi-terminal control via the MCP protocol.

Version Notes

The current v2 version is incompatible with the v1 partition table, so it is not possible to upgrade from v1 to v2 via OTA. For partition table details, see partitions/v2/README.md.

All hardware running v1 can be upgraded to v2 by manually flashing the firmware.

The stable version of v1 is 1.9.2. You can switch to v1 by running git checkout v1. The v1 branch will be maintained until February 2026.

Features Implemented

Wi-Fi / ML307 Cat.1 4G
Offline voice wake-up ESP-SR
Supports two communication protocols (Websocket or MQTT+UDP)
Uses OPUS audio codec
Voice interaction based on streaming ASR + LLM + TTS architecture
Speaker recognition, identifies the current speaker 3D Speaker
OLED / LCD display, supports emoji display
Battery display and power management
Multi-language support (Chinese, English, Japanese)
Supports ESP32-C3, ESP32-S3, ESP32-P4 chip platforms
Device-side MCP for device control (Speaker, LED, Servo, GPIO, etc.)
Cloud-side MCP to extend large model capabilities (smart home control, PC desktop operation, knowledge search, email, etc.)
Customizable wake words, fonts, emojis, and chat backgrounds with online web-based editing (Custom Assets Generator)

Hardware

Breadboard DIY Practice

See the Feishu document tutorial:

👉 "XiaoZhi AI Chatbot Encyclopedia"

Breadboard demo:

Supports 70+ Open Source Hardware (Partial List)

Software

Firmware Flashing

For beginners, it is recommended to use the firmware that can be flashed without setting up a development environment.

The firmware connects to the official xiaozhi.me server by default. Personal users can register an account to use the Qwen real-time model for free.

👉 Beginner's Firmware Flashing Guide

Development Environment

Cursor or VSCode
Install ESP-IDF plugin, select SDK version 5.4 or above
Linux is better than Windows for faster compilation and fewer driver issues
This project uses Google C++ code style, please ensure compliance when submitting code

Developer Documentation

Custom Board Guide - Learn how to create custom boards for XiaoZhi AI
MCP Protocol IoT Control Usage - Learn how to control IoT devices via MCP protocol
MCP Protocol Interaction Flow - Device-side MCP protocol implementation
MQTT + UDP Hybrid Communication Protocol Document
A detailed WebSocket communication protocol document

Large Model Configuration

If you already have a XiaoZhi AI chatbot device and have connected to the official server, you can log in to the xiaozhi.me console for configuration.

👉 Backend Operation Video Tutorial (Old Interface)

Related Open Source Projects

For server deployment on personal computers, refer to the following open-source projects:

xinnan-tech/xiaozhi-esp32-server Python server
joey-zhou/xiaozhi-esp32-server-java Java server
AnimeAIChat/xiaozhi-server-go Golang server
hackers365/xiaozhi-esp32-server-golang Golang server

Other client projects using the XiaoZhi communication protocol:

huangjunsen0406/py-xiaozhi Python client
TOM88812/xiaozhi-android-client Android client
100askTeam/xiaozhi-linux Linux client by 100ask
78/xiaozhi-sf32 Bluetooth chip firmware by Sichuan
QuecPython/solution-xiaozhiAI QuecPython firmware by Quectel

Custom Assets Tools:

78/xiaozhi-assets-generator Custom Assets Generator (Wake words, fonts, emojis, backgrounds)

About the Project

This is an open-source ESP32 project, released under the MIT license, allowing anyone to use it for free, including for commercial purposes.

We hope this project helps everyone understand AI hardware development and apply rapidly evolving large language models to real hardware devices.

If you have any ideas or suggestions, please feel free to raise Issues or join our Discord or QQ group: 994694848

Star History

MaaAssistantArknights/MaaAssistantArknights

《明日方舟》小助手，全日常一键长草！| A one-click tool for the daily tasks of Arknights, supporting all clients.

MAA

简体中文 | 繁體中文 | English | 日本語 | 한국어

MAA 的意思是 MAA Assistant Arknights

一款明日方舟游戏小助手

基于图像识别技术，一键完成全部日常任务！

绝赞更新中 ✿✿ヽ(°▽°)ノ✿

下载与安装

请阅读文档后前往官网或 Releases 下载，并参考新手上路进行安装。

亮点功能

理智作战，掉落识别及上传企鹅物流，一图流
智能基建换班，自动计算干员效率，单设施内最优解；同时也支持自定义排班
自动公招，可选使用加急许可，一次全部刷完！公招数据自动上传企鹅物流，一图流
支持手动识别公招界面，方便对高星公招做出选择 ~~（你的这个高资回费出的是推王呢还是推王呢）~~
支持识别干员列表，统计已有和未有干员及潜能，并在公招识别显示
支持识别养成材料，并导出至企鹅物流刷图规划、明日方舟工具箱、ARK-NIGHTS 干员培养表
访问好友、收取信用及购物、领取日常奖励等，一键全日常自动长草
肉鸽全自动刷源石锭和等级，自动烧水和凹直升，智能识别干员及练度
选择作业 JSON 文件，自动抄作业，视频演示
支持 C, Python, Java, Rust, Golang, Java HTTP, Rust HTTP 等多种接口，方便集成调用，自定义你的 MAA！

话不多说，看图！

使用说明

功能介绍

请参阅用户手册。

外服支持

目前国际服（美服）、日服、韩服、繁中服的绝大部分功能均已支持。但由于外服用户较少及项目人手不足，很多功能并没有进行全面的测试，所以请自行体验。
若您遇到了 Bug，或对某个功能有强需求，欢迎在 Issues 和讨论区催更；或加入我们一起建设 MAA！请参阅外服适配教程

CLI 支持

MAA 支持命令行界面（CLI）操作，支持 Linux，macOS 和 Windows，可用于自动化脚本或在无图形界面的服务器上使用。请参阅 CLI 使用指南

加入我们

主要关联项目

全新框架：MaaFramework
作业站前端：zoot-plus-frontend
作业站后端：ZootPlusBackend
官网：前端
深度学习：MaaAI

多语言 (i18n)

MAA 以中文（简体）为第一语言，翻译词条均以中文（简体）为准。

参与开发

请参阅开发指南。

API

外服适配

请参阅外服适配教程，对于国服已支持的功能，绝大部分的外服适配工作仅需要截图 + 简单的 JSON 修改即可。

Issue bot

请参阅 Issue Bot 使用方法

致谢

开源库

图像识别库：opencv
~~文字识别库：chineseocr_lite~~
文字识别库：PaddleOCR
深度学习部署库：FastDeploy
机器学习加速器：onnxruntime
~~关卡掉落识别：企鹅物流识别~~
地图格子识别：Arknights-Tile-Pos
C++ JSON 库：meojson
C++ 运算符解析器：calculator
~~C++ base64 编解码：cpp-base64~~
C++ 解压压缩库：zlib
C++ Gzip 封装：gzip-hpp
安卓触控事件器：Minitouch
安卓触控事件器：MaaTouch
WPF MVVM 框架：Stylet
WPF 控件库：HandyControl -> HandyControls
C# 日志：Serilog
C# JSON 库：Newtonsoft.Json & System.Text.Json
~~下载器：aria2~~

数据源

~~公开招募数据：明日方舟工具箱~~
~~干员及基建数据：PRTS Wiki~~
关卡数据：企鹅物流数据统计
游戏数据及资源：明日方舟客户端素材
游戏数据：《明日方舟》Yostar游戏数据

贡献/参与者

感谢所有参与到开发/测试中的朋友们，是大家的帮助让 MAA 越来越好！ (*´▽｀)ノノ

声明

本软件使用 GNU Affero General Public License v3.0 only 开源，并附带额外用户协议。
本软件 logo 并非使用 AGPL 3.0 协议开源，耗毛、vie 两位画师及软件全体开发者保留所有权利。不得以 AGPL 3.0 协议已授权为由在未经授权的情况下使用本软件 logo，不得在未经授权的情况下将本软件 logo 用于任何商业用途。
本软件开源、免费，仅供学习交流使用。若您遇到商家使用本软件进行代练并收费，可能是设备与时间等费用，产生的问题及后果与本软件无关。

DirectML 支持说明

本软件支持 GPU 加速功能，其在 Windows 平台上依赖于 Microsoft 提供的独立组件 DirectML。DirectML 并非本项目的开源部分，也不受 AGPL 3.0 的约束。为方便用户，我们随安装包附带了一个未经修改的 DirectML.dll 文件。如果您无需 GPU 加速功能，可安全删除该 DLL 文件，软件的核心功能仍可正常运行。

grpc/grpc

C++ based gRPC (C++, Python, Ruby, Objective-C, PHP, C#)

gRPC – An RPC library and framework

gRPC is a modern, open source, high-performance remote procedure call (RPC) framework that can run anywhere. gRPC enables client and server applications to communicate transparently, and simplifies the building of connected systems.

Homepage:	grpc.io
Mailing List:	grpc-io@googlegroups.com

To start using gRPC

To maximize usability, gRPC supports the standard method for adding dependencies to a user's chosen language (if there is one). In most languages, the gRPC runtime comes as a package available in a user's language package manager.

For instructions on how to use the language-specific gRPC runtime for a project, please refer to these documents

C++: follow the instructions under the src/cpp directory
C#/.NET: NuGet packages Grpc.Net.Client, Grpc.AspNetCore.Server
Dart: pub package grpc
Go: go get google.golang.org/grpc
Java: Use JARs from Maven Central Repository
Kotlin: Use JARs from Maven Central Repository
Node: npm install @grpc/grpc-js
Objective-C: Add gRPC-ProtoRPC dependency to podspec
PHP: pecl install grpc
Python: pip install grpcio
Ruby: gem install grpc
WebJS: follow the grpc-web instructions

Per-language quickstart guides and tutorials can be found in the documentation section on the grpc.io website. Code examples are available in the examples directory.

Precompiled bleeding-edge package builds of gRPC master branch's HEAD are uploaded daily to packages.grpc.io.

To start developing gRPC

Contributions are welcome!

Please read How to contribute which will guide you through the entire workflow of how to build the source code, how to run the tests, and how to contribute changes to the gRPC codebase. The "How to contribute" document also contains info on how the contribution process works and contains best practices for creating contributions.

Troubleshooting

Sometimes things go wrong. Please check out the Troubleshooting guide if you are experiencing issues with gRPC.

Performance

See the Performance dashboard for performance numbers of master branch daily builds.

Concepts

See gRPC Concepts

About This Repository

This repository contains source code for gRPC libraries implemented in multiple languages written on top of a shared C++ core library src/core.

Libraries in different languages may be in various states of development. We are seeking contributions for all of these libraries:

Language	Source
Shared C++ [core library]	src/core
C++	src/cpp
Ruby	src/ruby
Python	src/python
PHP	src/php
C# (core library based)	src/csharp
Objective-C	src/objective-c

Language	Source repo
Java	grpc-java
Kotlin	grpc-kotlin
Go	grpc-go
NodeJS	grpc-node
WebJS	grpc-web
Dart	grpc-dart
.NET (pure C# impl.)	grpc-dotnet
Swift	grpc-swift

tenstorrent/tt-metal

🤘 TT-NN operator library, and TT-Metalium low level kernel programming model.

Hardware | Install | Discord | Join Us | Bounty $

TT-NN is a Python & C++ Neural Network OP library.

API Reference | Model Demos

Featured Models

The Models team is focused on developing the following models, optimizing them for performance, accuracy, and compatibility. Follow each model link for more details.

Important

For a full model list see the Model Matrix, or visit the Developer Hub.

Note

Performance Metrics:

Time to First Token (TTFT) measures the time (in milliseconds) it takes to generate the first output token after input is received.
T/S/U (Tokens per Second per User): Represents the throughput of first-token generation after prefill. It is calculated as 1 / inter-token latency.
T/S (Tokens per Second): Represents total token throughput, calculated as T/S = T/S/U x batch size.
TP (Tensor Parallel) and DP (Data Parallel): Indicate the parallelization factors across multiple devices.
Reported LLM Performance: Based on an input sequence length of 128 tokens for all models.
Performance Data Source: Metrics were collected using the tt-metal model demos (linked above). Results may vary when using other runtimes such as the vLLM inference server.

Llama 3.3 70B (TP=32)

Batch	Hardware	TTFT (MS)	T/S/U	Target T/S/U	T/S	TT-Metalium Release	vLLM Tenstorrent Repo Release
32	Galaxy (Wormhole)	53	72.5	80	2268.8	v0.65.0-rc7	59be953

Qwen 2.5 7B (TP=2)

Batch	Hardware	TTFT (MS)	T/S/U	Target T/S/U	T/S	TT-Metalium Release	vLLM Tenstorrent Repo Release
32	n300 (Wormhole)	109	22.1	30	707.2	v0.62.0-rc35	ced0161

Qwen 2.5 72B (TP=8)

Batch	Hardware	TTFT (MS)	T/S/U	Target T/S/U	T/S	TT-Metalium Release	vLLM Tenstorrent Repo Release
32	QuietBox (Wormhole)	223	15.4	20	492.8	v0.62.0-rc25	e7c329b

Whisper (distil-large-v3)

Batch	Hardware	TTFT (MS)	T/S/U	Target T/S/U	T/S	TT-Metalium Release
1	n150 (Wormhole)	163	105.0	45	105.0	v0.65.0-dev20251208
1	p150 (Blackhole)	63	263.4		263.4	v0.65.0-dev20251208

Mixtral 8x7B (TP=8)

Batch	Hardware	TTFT (MS)	T/S/U	Target T/S/U	T/S	TT-Metalium Release
32	QuietBox (Wormhole)	122	24.9	33	796.8	v0.62.0-dev20251015

Blackhole software optimization is under active development. Please join us in shaping the future of open source AI!
[Discord] [Developer Hub]

For more information regarding vLLM installation and environment creation visit the Tenstorrent vLLM TT plugin README.

Model Updates

For the latest model updates and features, please see MODEL_UPDATES.md

Model Bring-Up and Testing

For information on initial model procedures, please see Model Bring-Up and Testing

TT-NN Tech Reports

Advanced Performance Optimizations for Models (updated March 4th, 2025)
ViT Implementation in TT-NN on GS (updated Sept 22nd, 2024)
LLMs Bring up in TT-NN (updated Oct 29th, 2024)
CNN Bring up & Optimization in TT-NN (updated Jan 22nd, 2025)

Benchmarks

Matrix Multiply FLOPS on Wormhole and Blackhole (updated June 17th, 2025)

TT-Metalium is our low-level programming model, enabling kernel development for Tenstorrent hardware.

Programming Guide | API Reference

Getting started

Get started with simple kernels.

TT-Metalium Tech Reports

Matrix Engine (updated Sept 6th, 2024)
Data Formats (updated Sept 7th, 2024)
Reconfiguring Data Formats (updated Oct 17th, 2024)
Handling special floating-point numbers (updated Oct 5th, 2024)
Allocator (Updated Dec 19th, 2024)
Tensor Layouts (updated Sept 6th, 2024)
Saturating DRAM Bandwidth (updated Sept 6th, 2024)
Flash Attention on Wormhole (updated Sept 6th, 2024)
CNNs on TT Architectures (updated Sept 6th, 2024)
Ethernet and Multichip Basics (Updated Sept 20th, 2024)
Blackhole Bring-Up Programming Guide (Updated Dec 18th, 2024)
Sub-Devices (Updated Jan 7th, 2025)

Scaleout Tech Reports

Programming Mesh of Devices (Scale-Up) (updated Jan 6th, 2026)
Programming Multiple Meshes (Scale-Out) (updated Jan 19th, 2026)
TT-Fabric Architecture (updated Dec 1st, 2025)
TT-Distributed Architecture (updated Oct 20th, 2025)

TT-Metalium Programming Examples

Hello World

Add Integers

Simple Tensor Manipulation

DRAM Data Movement

Dram Loopback Data Movement

Eltwise

Matmul

Tools and Instruments

TT-NN Visualizer

A comprehensive tool for visualizing and analyzing model execution, offering interactive graphs, memory plots, tensor details, buffer overviews, operation flow graphs, and multi-instance support with file or SSH-based report loading.

TT-Exalens

The TT-Exalens repository describes TT-Lensium, a low-level debugging tool for Tenstorrent hardware. It allows developers to access and communicate with Wormhole and Blackhole devices.

TT-SMI

The TT-SMI repository describes the Tenstorrent System Management Interface. This command line utility can interact with Tenstorrent devices on host. TT-SMI provides an easy to use interface displaying device, telemetry, and firmware information.

Model Explorer

The Model Explorer is an intuitive and hierarchical visualization tool using model graphs. It organizes model operations into nested layers and provides features for model exploration and debugging.

Tracy Profiler

The Tracy Profiler is a real-time nanosecond resolution, remote telemetry, hybrid frame, and sampling tool. Tracy supports profiling CPU, GPU, memory allocation, locks, context switches, and more.

Kernel Print Debug

DPRINT can print variables, addresses, and circular buffer data from kernels to the host terminal or log file. This feature is useful for debugging issues with kernels.

Watcher

Watcher monitors firmware and kernels for common programming errors, and overall device status. If an error or hang occurs, Watcher displays log data of that occurrence.

Inspector

Inspector provides insights into host runtime. It logs necessary data for investigation and allows queries to host runtime data.

Related Tenstorrent Projects

Latest Releases

Release	Release Date	FW Version	KMD Version	SMI Version
0.68.0	ETA Apr 30, 2026	19.2.0	2.5.0	3.0.38
0.67.4	Mar 30, 2026	19.2.0	2.5.0	3.0.38
0.67.0	Mar 25, 2026	19.2.0	2.5.0	3.0.38
0.66.0	Feb 18, 2026	19.2.0	2.5.0	3.0.38
0.65.1	Jan 12, 2026	19.2.0	2.5.0	3.0.38
0.65.0	Dec 15, 2025	19.2.0	2.5.0	3.0.38
0.64.5	Dec 1, 2025	18.12.0	2.4.1	3.0.32
0.64.4	Nov 24, 2025	18.12.0	2.4.1	3.0.32
0.64.3	Nov 14, 2025	18.12.0	2.4.1	3.0.32
0.64.0	Oct 29, 2025	18.12.0	2.4.1	3.0.32
0.63.0	Sep 22, 2025	18.8.0	2.3.0	3.0.28
0.62.2	Aug 20, 2025	18.6.0	2.0.0	3.0.20
0.61.0	Skipped	-	-	-
0.60.1	Jul 22, 2025	18.6.0	2.0.0	3.0.20
0.59.0	Jun 18, 2025	-	-	-
0.58.0	May 13, 2025	-	-	-
0.57.0	Apr 15, 2025	-	-	-
0.56.0	Mar 7, 2025	-	-	-

Visit the releases folder for details on releases, release notes, and estimated release dates.

Tenstorrent Bounty Program Terms and Conditions

This repo is a part of Tenstorrent’s bounty program. If you are interested in helping to improve tt-metal, please make sure to read the Tenstorrent Bounty Program Terms and Conditions before heading to the issues tab. Look for the issues that are tagged with both “bounty” and difficulty level!

License

TT-Metalium and TTNN are licensed under the Apache 2.0 License, as detailed in LICENSE and LICENSE_understanding.txt.

Some distributable forms of this project—such as manylinux-compliant wheels—may need to bundle additional libraries beyond the standard Linux system libraries. For example:

libnuma
libhwloc
openmpi (when built with multihost support)
libevent (when built with multihost support)

These libraries are bound by their own license terms.

jarczakpawel/BMCU-C-PJARCZAK

BMCU 370C (Hall) firmware for Bambu Lab A1 / A1 mini / P1S with buffer calibration - all known issues fixed, 100% AMS-compatible behavior.

BMCU Firmware – Calibration and Compatibility Notes

This BMCU firmware has been tested and verified with the latest Bambu Lab A1 firmware.

IMPORTANT: The printer must be configured as AMS, not AMS Lite. Using AMS Lite will cause incompatibility issues.

Support

Bambu Lab continues tightening compatibility around BMCU, and there is a growing risk that BMCU may eventually become unusable in that ecosystem.

To prepare for that, I want to build BMCU support for open-source Klipper-based printers.

I am currently raising funds to buy a test printer for this work.

The $500 goal does not need to be reached in full. If I manage to save the remaining amount myself, I will cover the rest out of my own pocket.

Support on Ko-fi · Support via Revolut

Direct Revolut support avoids Ko-fi fees, so more of your contribution goes directly to the project.

❗ IMPORTANT - FIRST START (V10.3+) ❗

At the first startup after flashing, all channels must be empty.

From V10.3, the firmware calibrates empty-channel detection during first boot.

If you flashed it with filament inserted:

remove all filament
hold any one buffer for about 5 seconds to re-calibrate

❗ Warning for 2nd generation printers

A lot of people make a mistake because the drawings are misleading, and it is not always clear from the diagrams whether they show the plug or the socket. As a result, Signal A and Signal B often get connected the wrong way around.

If your BMCU is not detected by a 2nd generation printer, try swapping Signal A and Signal B - but make sure you know exactly what you are doing.

HMS WARNING STATUS

This firmware version triggers an HMS warning immediately after printer startup.

Important clarification:

This HMS warning does NOT block BMCU operation
It does NOT require restarting the printer
It does NOT affect printing
The printer works normally despite the warning
The issue is purely visual / informational (HMS icon only)

At the moment, the HMS warning is known and accepted behavior in this firmware version.

If the HMS warning in Bambu Studio annoys you: I made a Bambu Studio build that bypasses this specific AMS compatibility warning, so you do not see it anymore. Other HMS warnings will still be visible (if they happen), so HMS remains useful.

https://github.com/jarczakpawel/BambuStudio-BMCU

Supported printers

Correct operation has been confirmed on both 1st generation and 2nd generation printers.

1st generation printers

Support is confirmed for 1st generation printers.

2nd generation printers

Correct operation has been confirmed on:

Bambu Lab P2S
Bambu Lab H2D

At this point, it looks like it should work on all printers from both generations.

Download

Please download ready-to-use firmware from the "Releases" section (right side of the GitHub page). All firmware variants are generated there together with .txt guides that explain which build you should choose.

Start by selecting the correct printer mode folder first (standard(A1) or high_force_load(P1S)), then choose AUTOLOAD / RGB / slots as usual.

Flashing

To flash any version of the BMCU (USB or TTL) on:

Windows
Linux
macOS
Android

use BMCU Flasher:

https://github.com/jarczakpawel/BMCU-Flasher

Precompiled binaries are available in the Releases section.

The flashing process is very simple and does not require wchisptool.

You can flash firmware in two ways:

Online flashing directly from the built-in wizard (recommended)
→ the flasher downloads the correct firmware automatically, so you do not need to download any .bin files manually.
Local flashing using a firmware file you downloaded yourself.

The flasher also supports Android, so you can even flash the BMCU directly from your phone 🙂

IMPORTANT:

Do NOT flash the BMCU while it is connected to the printer.
Do NOT connect or disconnect the BMCU while the printer is powered on (risk of damaging the BMCU and/or the printer mainboard).

SOLO firmware

Example file:

solo_0.095f.bin

This firmware is intended for single BMCU (SOLO) operation.

Recommended for single-BMCU setups
Filament retraction length: 9.5 cm

Filament retraction explanation

Filament retraction must be calculated from the end of the AMS splitter inside the printer (the plastic AMS part where four PTFE tubes enter).

Example:

Distance from BMCU to the end of the AMS splitter: approximately 9.0 cm
SOLO firmware retracts the filament about 0.5 cm past the splitter
Total retraction length: 9.5 cm

When calculating your own retraction length:

Always measure from the end of the AMS splitter
Add the required distance plus approximately 9 cm, depending on your setup

AMS_A / AMS_B / AMS_C / AMS_D firmware

These firmware versions are intended for:

Multi-BMCU setups
Longer filament retraction distances

If you want to use SOLO mode with a longer retraction, use AMS_A instead of SOLO.

Calibration (first start)

Correct calibration is mandatory. Without proper calibration, BMCU will not work correctly.

The calibration process is shown in the following video:

https://www.youtube.com/watch?v=Hn_DNzSmhuc

Follow the calibration steps shown in the video carefully.

Re-calibration

You can recalibrate the BMCU at any time.

Steps:

Remove all filaments from all channels
Hold any one buffer in position for approximately 5 seconds

Safety and usage notes

Do not flash BMCU while it is connected to the printer
Do not disconnect BMCU while the printer is powered on
Do not update printer firmware while BMCU is connected
Connect/disconnect the BMCU ONLY when the printer is completely powered off (unplugged). Doing this while powered can damage the BMCU and/or the printer mainboard.

These recommendations are based on community reports. Not all failure scenarios have been tested.

Changing the printer mode from AMS Lite to AMS while BMCU was connected did not cause issues in testing, but this is not recommended.

Disclaimer

You are using this firmware and performing any modifications at your own risk. Make sure you understand what you are doing. I am not responsible for any damage, failed prints, hardware issues, or data loss.

Before opening a bug report

Please verify the basics first:

Make sure you flashed the correct firmware variant and followed the flashing tutorial correctly.
Make sure you really have BMCU 370C with Hall sensors.
- The only reliable verification is to open the module and inspect the PCB.
- Some sellers mix modules and try to get rid of older 370x boards - sometimes 1-2 modules in the set can be 370x.
If you have printer-side issues:
- confirm you are on the latest printer firmware
- do a factory reset (this often fixes weird AMS-related behavior)
If filament detection behaves strangely:
- boot the printer once without BMCU connected
- then connect BMCU and test again
Do a few real tests before creating a thread. Printers can have unrelated issues (rare, but happens) - some users cannot even update printer firmware automatically and must do it via SD card.

Bug reports

If you encounter a real bug, you may report it. This firmware has undergone solid testing, and no issues are expected.

Changelog

V10.5

User-visible changes

Added automatic filament unload when the buffer is lifted manually.
The serial is generated from the MCU hardware UID, so devices no longer share the same SN.
Calibration now performs a full NVM cleanup.
Fixed the rare issue where the system LED could blink incorrectly on some BMCU units.
Fixed the external fan issue on Bambu Lab P2S.

V10.4

User-visible changes

Added support for Bambu Lab P2S.
- Verified to work correctly in real tests.
- The H2 series will most likely also work as well, because 1st generation AMS support is confirmed there.

Fixes

"filament in use" flag is now cleared correctly when filament runs out during printing.
Added support for retraction when the buffer is pulled up manually, even when there is no filament inside.

V10.3

User-visible changes

Added new firmware mode: soft_load(A1).
- Intended mainly for A1 / A1 Mini users.
- Uses lower filament loading force than standard(A1).
- Useful for some BMCU units with weaker lever springs, where stronger loading can cause clicking / grinding during filament load.
Improved empty-channel detection calibration.
- The firmware now calibrates and stores the "no filament" detection point separately for each channel.
- This improves reliability on hardware variants where idle detection voltage differs between channels/modules.
Improved calibration behavior:
- calibration now also detects and saves Hall polarity per channel
- magnet polarity is automatically detected during calibration and stored, so it no longer matters which way the magnet is inserted in the buffer

Stability and behavior improvements

Fixed PWM timer preload configuration on all motor channels.
- PWM updates are now buffered correctly before timer update events.
Improved AS5600 update timing.
- Sensor polling is now rate-limited to about 1 ms
- more stable speed calculation
- lower unnecessary CPU load
Improved internal timing paths by reusing shared tick snapshots in the main motion loop.
- less timing jitter
- more consistent runtime behavior
Improved high-load / jam timing logic during on_use.
- high PWM accumulation now uses microsecond precision instead of millisecond buckets
Improved motion loop time-step handling.
- uses wrap-safe tick delta
- clamps oversized time steps
- avoids running motor control with invalid zero-step timing

Notes

soft_load(A1) is not meant as the default for everyone.
If filament gets rejected because push force is too weak, switch back to standard(A1) and use a stronger lever spring.
On some A1 / A1 Mini units, soft_load(A1) works very well and can be used permanently.

V10.2

User-visible changes

Fixed a problem where filament run-out could incorrectly trigger a jam condition.
When filament ended, the motor could run continuously and eventually enter jam protection, which blocked the automatic filament refill.
Reworked jam protection logic:
- real filament jams are now detected separately from temporary motor stops
- high motor load alone no longer falsely triggers a jam
Improved flash persistence system (less unnecessary flash rewriting).
Improved ADC/DMA processing:
- faster value updates
- lower CPU overhead
- smoother runtime behavior
Various timing and stability improvements.

Technical changes

Filament metadata flash storage redesigned.
- append-only journal instead of rewriting a full flash page
- each record: 40 bytes (10 words)
- CRC32 validation
- 6 records per flash page
- page erase only when the page becomes full
  This significantly reduces flash wear and makes writes power-loss safe.
Loaded-channel persistence reworked into a lightweight slot log to reduce erase cycles.
Added skip-if-unchanged logic to avoid unnecessary flash writes.
Simplified and optimized ADC DMA update/publish path.
CRC tables moved to static compile-time tables (no runtime generation).
Cleanup of timing paths using wrap-safe 32-bit timers.
Several other smaller fixes and internal optimizations.

V10

User-visible changes

Improved spool jam handling: jam is detected immediately, the print is paused, the printer waits for you to fix the snag/tangle, then you can resume normally without ruining the print.

Flash / persistence (wear + reliability)

State (loaded channel) persistence reworked into an append-only slot log: 8 bytes per update, up to 192 updates before any page erase (~192x fewer erase cycles vs rewriting a whole 256B page per update).
Filament metadata persistence reworked into a small CRC-protected log: 64B per update, 2 pages per filament (8 records) -> ~8x fewer erase cycles vs erasing a whole 256B page on every change.
Per-filament saves: only the modified channel is written (reduces unnecessary flash writes).
Power-loss safe commits: records are validated and partially-written data is ignored.

V9

User-visible changes

Increased filament loading force for improved reliability during filament insertion.
Improved filament loading behavior on some materials (e.g. Sunlu PLA+ and similar filaments) where loading characteristics differ from standard PLA/PETG.
Added protection against spool jams:
- Lock mode activates if the buffer drops too low during printing.
- Lock mode also activates if the motor runs at high speed continuously for ~8 seconds.
- The lock is automatically released once the buffer returns to the neutral position.
- Prevents prolonged motor overrun when filament movement is blocked.

V8

User-visible changes

Supported print resume after a printer power reset / power loss (printing can be resumed properly).
Improved behavior for P1S (loading problems due to long/bent PTFE path).
Added AUTOLOAD support for single-switch PCB boards:
- Triggered by pressing the buffer ("buffer tap").
- Starts filament loading exactly like the external switch trigger.
More stable loading process overall.
Improved support for low-torque BMCU variants.

V7

User-visible changes

Remember loaded filaments (persistent state).
You can load filament and safely power off the printer.
This allows you to disable the automatic unload-at-end behavior in G-code (if you often print with one filament), keeping filament loaded until you actually need to change it.
More info here: https://wiki.bambulab.com/en/ams/manual/ams-not-unloading-to-save-filament
100% solved filament loading problems. The system is stable and consistent across hardware variants.
Filament RGB colors. Modules/LEDs can display the configured filament color.

AUTOLOAD (short)

How AUTOLOAD works

DM (two microswitches):
- Touch first switch → AUTOLOAD starts (you may need a light manual push until gears grab).
- BMCU feeds filament until the second switch (behind extruder) confirms fully inserted.
- Then it feeds 120 mm to make it print-ready.
- Anti-snag protection: buffer position is monitored; if the filament catches on housing / PTFE edge, it retracts to safe position and retries (3 retries).
Single-switch boards:
- Stage 1 is manual (no second switch to confirm fully-in).
- Once filament is fully in the extruder, Stage 2 behaves the same (incl. anti-snag protection).

Technical changes

ADC_DMA upgraded (ADC1 + ADC2 in parallel):
- Regular simultaneous mode: ADC1+ADC2 scan channels in parallel to reduce noise and increase throughput.
- Lower noise enabled smaller filtering and faster stable readout.
- Full filtered update time: ~5 ms instead of ~28 ms.
AS5600 reading correctness improved (robustness and stability of reads).
Timer/tick safety (wrap safety): all time comparisons reviewed to be correct under wrap-around.
Final stabilization and cleanup: overall behavior is faster and more deterministic than previous releases.
There were more fixes in V7 as well; easiest is to check the commit history.

Final note: all known issues were ultimately resolved. BMCU is fully stable and significantly faster vs older firmware. At this moment I do not expect any further fixes.

V6

Framework

Dropped Arduino Core (PlatformIO: framework = arduino) - the whole firmware was rewritten to pure CH32 (WCH SDK / noneos).
Direct use of hardware timers, DMA and interrupts - no Arduino delays, no random timing, deterministic real-time behavior.
Faster and correct flash operations (WCH Fast API) - stable writes, faster, without corrupting neighboring data.

ADC_DMA

Separated DMA writes from CPU reads - previously reads happened while DMA was overwriting the buffer.
Filter is computed in the background (DMA half/full), not during readout - previously get_value() blocked CPU and broke timing.
Constant CPU load - previously larger filter window slowed the system down.
DMA error handling

BUS (BambuBus + AHUB)

Fixed RX/TX buffer race (reading and overwriting the same buffer at the same time).
Snapshot-based parsing instead of working on a live buffer
Deterministic frame handling timing - constant CPU cost, independent from packet length.
Robustness against transmission errors - a bad packet does not break the whole system state.

Flash / NVM

Flash written page-by-page (256B) instead of erasing/programming the whole sector (4KB)
Write only when data actually changed
Hardware CRC for flash + verification on read
AMS data split into separate records - changing one filament does not rewrite the whole structure.

Soft-I2C / AS5600

Rewritten from Arduino, removed timing bugs and Arduino "magic".
Correct ACK/NACK, START/STOP, recovery handling
Hard isolation of channels with errors

Motion / mechanics

Smoother motor control
Added calibration buffers - filament stays in a neutral position, without unnecessary tension.
Better state transitions - no jerks and no sudden braking.

Misc

CRC8 / CRC16 rewritten to simple C + lookup tables - faster, deterministic, no objects and no runtime init.
Partially de-spaghettified includes
and many more - firmware prepared for further development

Final note

This firmware started as a personal CH32 learning project. During development it grew far beyond the original scope because working on BMCU turned out to be genuinely enjoyable.

Many solutions are intentionally overengineered. Everything was implemented primarily for personal use and experimentation.

The firmware has been used extensively during development, and no practical issues were observed in real-world usage.

nlohmann/json

JSON for Modern C++

Design goals

There are myriads of JSON libraries out there, and each may even have its reason to exist. Our class had these design goals:

Intuitive syntax. In languages such as Python, JSON feels like a first-class data type. We used all the operator magic of modern C++ to achieve the same feeling in your code. Check out the examples below and you'll know what I mean.
Trivial integration. Our whole code consists of a single header file json.hpp. That's it. No library, no subproject, no dependencies, no complex build system. The class is written in vanilla C++11. All in all, everything should require no adjustment of your compiler flags or project settings. The library is also included in all popular package managers.
Serious testing. Our code is heavily unit-tested and covers 100% of the code, including all exceptional behavior. Furthermore, we checked with Valgrind and the Clang Sanitizers that there are no memory leaks. Google OSS-Fuzz additionally runs fuzz tests against all parsers 24/7, effectively executing billions of tests so far. To maintain high quality, the project is following the Core Infrastructure Initiative (CII) best practices. See the quality assurance overview documentation.

Other aspects were not so important to us:

Memory efficiency. Each JSON object has an overhead of one pointer (the maximal size of a union) and one enumeration element (1 byte). The default generalization uses the following C++ data types: std::string for strings, int64_t, uint64_t or double for numbers, std::map for objects, std::vector for arrays, and bool for Booleans. However, you can template the generalized class basic_json to your needs.
Speed. There are certainly faster JSON libraries out there. However, if your goal is to speed up your development by adding JSON support with a single header, then this library is the way to go. If you know how to use a std::vector or std::map, you are already set.

See the contribution guidelines for more information.

Support

❓ If you have a question, please check if it is already answered in the FAQ or the Q&A section. If not, please ask a new question there.

📚 If you want to learn more about how to use the library, check out the rest of the README, have a look at code examples, or browse through the help pages.

🚧 If you want to understand the API better, check out the API Reference or have a look at the quick reference below.

🐛 If you found a bug, please check the FAQ if it is a known issue or the result of a design decision. Please also have a look at the issue list before you create a new issue. Please provide as much information as possible to help us understand and reproduce your issue.

There is also a docset for the documentation browsers Dash, Velocity, and Zeal that contains the full documentation as an offline resource.

Quick reference

Constructors basic_json, array, binary, object
Object inspection: type, operator value_t, type_name, is_primitive, is_structured, is_null, is_boolean, is_number, is_number_integer, is_number_unsigned, is_number_float, is_object, is_array, is_string, is_binary, is_discarded
Value access; get, get_to, get_ptr, get_ref, operator ValueType, get_binary
Element access: at, operator[], value, front, back
Lookup: find, count, contains
Iterators: begin, cbegin, end, cend, rbegin, rend, crbegin, crend, items
Capacity: empty, size, max_size
Modifiers: clear, push_back, operator+=, emplace_back, emplace, erase, insert, update, swap
Lexicographical comparison operators: operator==, operator!=, operator<, operator>, operator<=, operator>=, operator<=>
Serialization / Dumping: dump
Deserialization / Parsing: parse, accept, sax_parse
JSON Pointer functions: flatten, unflatten
JSON Patch functions: patch, patch_inplace, diff, merge_patch
Static functions: meta, get_allocator
Binary formats: from_bjdata, from_bson, from_cbor, from_msgpack, from_ubjson, to_bjdata, to_bson, to_cbor, to_msgpack, to_ubjson
Non-member functions: operator<<, operator>>, to_string
Literals: operator""_json
Helper classes: std::hash<basic_json>, std::swap<basic_json>

Full API documentation

Examples

Here are some examples to give you an idea how to use the class.

Besides the examples below, you may want to:

→ Check the documentation
→ Browse the standalone example files
→ Read the full API Documentation with self-contained examples for every function

Read JSON from a file

The json class provides an API for manipulating a JSON value. To create a json object by reading a JSON file:

#include <fstream>
#include <nlohmann/json.hpp>
using json = nlohmann::json;

// ...

std::ifstream f("example.json");
json data = json::parse(f);

If using modules (enabled with NLOHMANN_JSON_BUILD_MODULES), this example becomes:

import std;
import nlohmann.json;

using json = nlohmann::json;

// ...

std::ifstream f("example.json");
json data = json::parse(f);

Creating `json` objects from JSON literals

Assume you want to hard-code this literal JSON value as a json object:

{
  "pi": 3.141,
  "happy": true
}

There are various options:

// Using (raw) string literals and json::parse
json ex1 = json::parse(R"(
  {
    "pi": 3.141,
    "happy": true
  }
)");

// Using user-defined (raw) string literals
using namespace nlohmann::literals;
json ex2 = R"(
  {
    "pi": 3.141,
    "happy": true
  }
)"_json;

// Using initializer lists
json ex3 = {
  {"happy", true},
  {"pi", 3.141},
};

JSON as a first-class data type

Here are some examples to give you an idea how to use the class.

Assume you want to create the JSON object

{
  "pi": 3.141,
  "happy": true,
  "name": "Niels",
  "nothing": null,
  "answer": {
    "everything": 42
  },
  "list": [1, 0, 2],
  "object": {
    "currency": "USD",
    "value": 42.99
  }
}

With this library, you could write:

// create an empty structure (null)
json j;

// add a number stored as double (note the implicit conversion of j to an object)
j["pi"] = 3.141;

// add a Boolean stored as bool
j["happy"] = true;

// add a string stored as std::string
j["name"] = "Niels";

// add another null object by passing nullptr
j["nothing"] = nullptr;

// add an object inside the object
j["answer"]["everything"] = 42;

// add an array stored as std::vector (using an initializer list)
j["list"] = { 1, 0, 2 };

// add another object (using an initializer list of pairs)
j["object"] = { {"currency", "USD"}, {"value", 42.99} };

// instead, you could also write (which looks very similar to the JSON above)
json j2 = {
  {"pi", 3.141},
  {"happy", true},
  {"name", "Niels"},
  {"nothing", nullptr},
  {"answer", {
    {"everything", 42}
  }},
  {"list", {1, 0, 2}},
  {"object", {
    {"currency", "USD"},
    {"value", 42.99}
  }}
};

Note that in all these cases, you never need to "tell" the compiler which JSON value type you want to use. If you want to be explicit or express some edge cases, the functions json::array() and json::object() will help:

// a way to express the empty array []
json empty_array_explicit = json::array();

// ways to express the empty object {}
json empty_object_implicit = json({});
json empty_object_explicit = json::object();

// a way to express an _array_ of key/value pairs [["currency", "USD"], ["value", 42.99]]
json array_not_object = json::array({ {"currency", "USD"}, {"value", 42.99} });

Serialization / Deserialization

To/from strings

You can create a JSON value (deserialization) by appending _json to a string literal:

// create object from string literal
json j = "{ \"happy\": true, \"pi\": 3.141 }"_json;

// or even nicer with a raw string literal
auto j2 = R"(
  {
    "happy": true,
    "pi": 3.141
  }
)"_json;

Note that without appending the _json suffix, the passed string literal is not parsed, but just used as JSON string value. That is, json j = "{ \"happy\": true, \"pi\": 3.141 }" would just store the string "{ "happy": true, "pi": 3.141 }" rather than parsing the actual object.

The string literal should be brought into scope with using namespace nlohmann::literals; (see json::parse()).

The above example can also be expressed explicitly using json::parse():

// parse explicitly
auto j3 = json::parse(R"({"happy": true, "pi": 3.141})");

You can also get a string representation of a JSON value (serialize):

// explicit conversion to string
std::string s = j.dump();    // {"happy":true,"pi":3.141}

// serialization with pretty printing
// pass in the amount of spaces to indent
std::cout << j.dump(4) << std::endl;
// {
//     "happy": true,
//     "pi": 3.141
// }

Note the difference between serialization and assignment:

// store a string in a JSON value
json j_string = "this is a string";

// retrieve the string value
auto cpp_string = j_string.get<std::string>();
// retrieve the string value (alternative when a variable already exists)
std::string cpp_string2;
j_string.get_to(cpp_string2);

// retrieve the serialized value (explicit JSON serialization)
std::string serialized_string = j_string.dump();

// output of original string
std::cout << cpp_string << " == " << cpp_string2 << " == " << j_string.get<std::string>() << '\n';
// output of serialized value
std::cout << j_string << " == " << serialized_string << std::endl;

.dump() returns the originally stored string value.

Note the library only supports UTF-8. When you store strings with different encodings in the library, calling dump() may throw an exception unless json::error_handler_t::replace or json::error_handler_t::ignore are used as error handlers.

To/from streams (e.g., files, string streams)

You can also use streams to serialize and deserialize:

// deserialize from standard input
json j;
std::cin >> j;

// serialize to standard output
std::cout << j;

// the setw manipulator was overloaded to set the indentation for pretty printing
std::cout << std::setw(4) << j << std::endl;

These operators work for any subclasses of std::istream or std::ostream. Here is the same example with files:

// read a JSON file
std::ifstream i("file.json");
json j;
i >> j;

// write prettified JSON to another file
std::ofstream o("pretty.json");
o << std::setw(4) << j << std::endl;

Please note that setting the exception bit for failbit is inappropriate for this use case. It will result in program termination due to the noexcept specifier in use.

Read from iterator range

You can also parse JSON from an iterator range; that is, from any container accessible by iterators whose value_type is an integral type of 1, 2, or 4 bytes, which will be interpreted as UTF-8, UTF-16, and UTF-32 respectively. For instance, a std::vector<std::uint8_t>, or a std::list<std::uint16_t>:

std::vector<std::uint8_t> v = {'t', 'r', 'u', 'e'};
json j = json::parse(v.begin(), v.end());

You may leave the iterators for the range [begin, end):

std::vector<std::uint8_t> v = {'t', 'r', 'u', 'e'};
json j = json::parse(v);

Custom data source

Since the parse function accepts arbitrary iterator ranges, you can provide your own data sources by implementing the LegacyInputIterator concept.

struct MyContainer {
  void advance();
  const char& get_current();
};

struct MyIterator {
    using difference_type = std::ptrdiff_t;
    using value_type = char;
    using pointer = const char*;
    using reference = const char&;
    using iterator_category = std::input_iterator_tag;

    MyIterator& operator++() {
        target->advance();
        return *this;
    }

    bool operator!=(const MyIterator& rhs) const {
        return rhs.target != target;
    }

    reference operator*() const {
        return target->get_current();
    }

    MyContainer* target = nullptr;
};

MyIterator begin(MyContainer& tgt) {
    return MyIterator{&tgt};
}

MyIterator end(const MyContainer&) {
    return {};
}

void foo() {
    MyContainer c;
    json j = json::parse(c);
}

SAX interface

The library uses a SAX-like interface with the following functions:

// called when null is parsed
bool null();

// called when a boolean is parsed; value is passed
bool boolean(bool val);

// called when a signed or unsigned integer number is parsed; value is passed
bool number_integer(number_integer_t val);
bool number_unsigned(number_unsigned_t val);

// called when a floating-point number is parsed; value and original string is passed
bool number_float(number_float_t val, const string_t& s);

// called when a string is parsed; value is passed and can be safely moved away
bool string(string_t& val);
// called when a binary value is parsed; value is passed and can be safely moved away
bool binary(binary_t& val);

// called when an object or array begins or ends, resp. The number of elements is passed (or -1 if not known)
bool start_object(std::size_t elements);
bool end_object();
bool start_array(std::size_t elements);
bool end_array();
// called when an object key is parsed; value is passed and can be safely moved away
bool key(string_t& val);

// called when a parse error occurs; byte position, the last token, and an exception is passed
bool parse_error(std::size_t position, const std::string& last_token, const detail::exception& ex);

The return value of each function determines whether parsing should proceed.

To implement your own SAX handler, proceed as follows:

Implement the SAX interface in a class. You can use class nlohmann::json_sax<json> as base class, but you can also use any class where the functions described above are implemented and public.
Create an object of your SAX interface class, e.g. my_sax.
Call bool json::sax_parse(input, &my_sax); where the first parameter can be any input like a string or an input stream and the second parameter is a pointer to your SAX interface.

Note the sax_parse function only returns a bool indicating the result of the last executed SAX event. It does not return a json value - it is up to you to decide what to do with the SAX events. Furthermore, no exceptions are thrown in case of a parse error -- it is up to you what to do with the exception object passed to your parse_error implementation. Internally, the SAX interface is used for the DOM parser (class json_sax_dom_parser) as well as the acceptor (json_sax_acceptor), see file json_sax.hpp.

STL-like access

We designed the JSON class to behave just like an STL container. In fact, it satisfies the ReversibleContainer requirement.

// create an array using push_back
json j;
j.push_back("foo");
j.push_back(1);
j.push_back(true);

// also use emplace_back
j.emplace_back(1.78);

// iterate the array
for (json::iterator it = j.begin(); it != j.end(); ++it) {
  std::cout << *it << '\n';
}

// range-based for
for (auto& element : j) {
  std::cout << element << '\n';
}

// getter/setter
const auto tmp = j[0].get<std::string>();
j[1] = 42;
bool foo = j.at(2);

// comparison
j == R"(["foo", 1, true, 1.78])"_json;  // true

// other stuff
j.size();     // 4 entries
j.empty();    // false
j.type();     // json::value_t::array
j.clear();    // the array is empty again

// convenience type checkers
j.is_null();
j.is_boolean();
j.is_number();
j.is_object();
j.is_array();
j.is_string();

// create an object
json o;
o["foo"] = 23;
o["bar"] = false;
o["baz"] = 3.141;

// also use emplace
o.emplace("weather", "sunny");

// special iterator member functions for objects
for (json::iterator it = o.begin(); it != o.end(); ++it) {
  std::cout << it.key() << " : " << it.value() << "\n";
}

// the same code as range for
for (auto& el : o.items()) {
  std::cout << el.key() << " : " << el.value() << "\n";
}

// even easier with structured bindings (C++17)
for (auto& [key, value] : o.items()) {
  std::cout << key << " : " << value << "\n";
}

// find an entry
if (o.contains("foo")) {
  // there is an entry with key "foo"
}

// or via find and an iterator
if (o.find("foo") != o.end()) {
  // there is an entry with key "foo"
}

// or simpler using count()
int foo_present = o.count("foo"); // 1
int fob_present = o.count("fob"); // 0

// delete an entry
o.erase("foo");

Conversion from STL containers

Any sequence container (std::array, std::vector, std::deque, std::forward_list, std::list) whose values can be used to construct JSON values (e.g., integers, floating point numbers, Booleans, string types, or again STL containers described in this section) can be used to create a JSON array. The same holds for similar associative containers (std::set, std::multiset, std::unordered_set, std::unordered_multiset), but in these cases the order of the elements of the array depends on how the elements are ordered in the respective STL container.

std::vector<int> c_vector {1, 2, 3, 4};
json j_vec(c_vector);
// [1, 2, 3, 4]

std::deque<double> c_deque {1.2, 2.3, 3.4, 5.6};
json j_deque(c_deque);
// [1.2, 2.3, 3.4, 5.6]

std::list<bool> c_list {true, true, false, true};
json j_list(c_list);
// [true, true, false, true]

std::forward_list<int64_t> c_flist {12345678909876, 23456789098765, 34567890987654, 45678909876543};
json j_flist(c_flist);
// [12345678909876, 23456789098765, 34567890987654, 45678909876543]

std::array<unsigned long, 4> c_array {{1, 2, 3, 4}};
json j_array(c_array);
// [1, 2, 3, 4]

std::set<std::string> c_set {"one", "two", "three", "four", "one"};
json j_set(c_set); // only one entry for "one" is used
// ["four", "one", "three", "two"]

std::unordered_set<std::string> c_uset {"one", "two", "three", "four", "one"};
json j_uset(c_uset); // only one entry for "one" is used
// maybe ["two", "three", "four", "one"]

std::multiset<std::string> c_mset {"one", "two", "one", "four"};
json j_mset(c_mset); // both entries for "one" are used
// maybe ["one", "two", "one", "four"]

std::unordered_multiset<std::string> c_umset {"one", "two", "one", "four"};
json j_umset(c_umset); // both entries for "one" are used
// maybe ["one", "two", "one", "four"]

Likewise, any associative key-value containers (std::map, std::multimap, std::unordered_map, std::unordered_multimap) whose keys can construct an std::string and whose values can be used to construct JSON values (see examples above) can be used to create a JSON object. Note that in case of multimaps, only one key is used in the JSON object and the value depends on the internal order of the STL container.

std::map<std::string, int> c_map { {"one", 1}, {"two", 2}, {"three", 3} };
json j_map(c_map);
// {"one": 1, "three": 3, "two": 2 }

std::unordered_map<const char*, double> c_umap { {"one", 1.2}, {"two", 2.3}, {"three", 3.4} };
json j_umap(c_umap);
// {"one": 1.2, "two": 2.3, "three": 3.4}

std::multimap<std::string, bool> c_mmap { {"one", true}, {"two", true}, {"three", false}, {"three", true} };
json j_mmap(c_mmap); // only one entry for key "three" is used
// maybe {"one": true, "two": true, "three": true}

std::unordered_multimap<std::string, bool> c_ummap { {"one", true}, {"two", true}, {"three", false}, {"three", true} };
json j_ummap(c_ummap); // only one entry for key "three" is used
// maybe {"one": true, "two": true, "three": true}

JSON Pointer and JSON Patch

The library supports JSON Pointer (RFC 6901) as an alternative means to address structured values. On top of this, JSON Patch (RFC 6902) allows describing differences between two JSON values -- effectively allowing patch and diff operations known from Unix.

// a JSON value
json j_original = R"({
  "baz": ["one", "two", "three"],
  "foo": "bar"
})"_json;

// access members with a JSON pointer (RFC 6901)
j_original["/baz/1"_json_pointer];
// "two"

// a JSON patch (RFC 6902)
json j_patch = R"([
  { "op": "replace", "path": "/baz", "value": "boo" },
  { "op": "add", "path": "/hello", "value": ["world"] },
  { "op": "remove", "path": "/foo"}
])"_json;

// apply the patch
json j_result = j_original.patch(j_patch);
// {
//    "baz": "boo",
//    "hello": ["world"]
// }

// calculate a JSON patch from two JSON values
json::diff(j_result, j_original);
// [
//   { "op":" replace", "path": "/baz", "value": ["one", "two", "three"] },
//   { "op": "remove","path": "/hello" },
//   { "op": "add", "path": "/foo", "value": "bar" }
// ]

JSON Merge Patch

The library supports JSON Merge Patch (RFC 7386) as a patch format. Instead of using JSON Pointer (see above) to specify values to be manipulated, it describes the changes using a syntax that closely mimics the document being modified.

// a JSON value
json j_document = R"({
  "a": "b",
  "c": {
    "d": "e",
    "f": "g"
  }
})"_json;

// a patch
json j_patch = R"({
  "a":"z",
  "c": {
    "f": null
  }
})"_json;

// apply the patch
j_document.merge_patch(j_patch);
// {
//  "a": "z",
//  "c": {
//    "d": "e"
//  }
// }

Implicit conversions

Supported types can be implicitly converted to JSON values.

It is recommended to NOT USE implicit conversions FROM a JSON value. You can find more details about this recommendation here. You can switch off implicit conversions by defining JSON_USE_IMPLICIT_CONVERSIONS to 0 before including the json.hpp header. When using CMake, you can also achieve this by setting the option JSON_ImplicitConversions to OFF.

// strings
std::string s1 = "Hello, world!";
json js = s1;
auto s2 = js.get<std::string>();
// NOT RECOMMENDED
std::string s3 = js;
std::string s4;
s4 = js;

// Booleans
bool b1 = true;
json jb = b1;
auto b2 = jb.get<bool>();
// NOT RECOMMENDED
bool b3 = jb;
bool b4;
b4 = jb;

// numbers
int i = 42;
json jn = i;
auto f = jn.get<double>();
// NOT RECOMMENDED
double f2 = jb;
double f3;
f3 = jb;

// etc.

Note that char types are not automatically converted to JSON strings, but to integer numbers. A conversion to a string must be specified explicitly:

char ch = 'A';                       // ASCII value 65
json j_default = ch;                 // stores integer number 65
json j_string = std::string(1, ch);  // stores string "A"

Arbitrary types conversions

Every type can be serialized in JSON, not just STL containers and scalar types. Usually, you would do something along those lines:

namespace ns {
    // a simple struct to model a person
    struct person {
        std::string name;
        std::string address;
        int age;
    };
}

ns::person p = {"Ned Flanders", "744 Evergreen Terrace", 60};

// convert to JSON: copy each value into the JSON object
json j;
j["name"] = p.name;
j["address"] = p.address;
j["age"] = p.age;

// ...

// convert from JSON: copy each value from the JSON object
ns::person p {
    j["name"].get<std::string>(),
    j["address"].get<std::string>(),
    j["age"].get<int>()
};

It works, but that's quite a lot of boilerplate... Fortunately, there's a better way:

// create a person
ns::person p {"Ned Flanders", "744 Evergreen Terrace", 60};

// conversion: person -> json
json j = p;

std::cout << j << std::endl;
// {"address":"744 Evergreen Terrace","age":60,"name":"Ned Flanders"}

// conversion: json -> person
auto p2 = j.get<ns::person>();

// that's it
assert(p == p2);

Basic usage

To make this work with one of your types, you only need to provide two functions:

using json = nlohmann::json;

namespace ns {
    void to_json(json& j, const person& p) {
        j = json{{"name", p.name}, {"address", p.address}, {"age", p.age}};
    }

    void from_json(const json& j, person& p) {
        j.at("name").get_to(p.name);
        j.at("address").get_to(p.address);
        j.at("age").get_to(p.age);
    }
} // namespace ns

That's all! When calling the json constructor with your type, your custom to_json method will be automatically called. Likewise, when calling get<your_type>() or get_to(your_type&), the from_json method will be called.

Some important things:

Those methods MUST be in your type's namespace (which can be the global namespace), or the library will not be able to locate them (in this example, they are in namespace ns, where person is defined).
Those methods MUST be available (e.g., proper headers must be included) everywhere you use these conversions. Look at issue 1108 for errors that may occur otherwise.
When using get<your_type>(), your_type MUST be DefaultConstructible. (There is a way to bypass this requirement described later.)
In function from_json, use function at() to access the object values rather than operator[]. In case a key does not exist, at throws an exception that you can handle, whereas operator[] exhibits undefined behavior.
You do not need to add serializers or deserializers for STL types like std::vector: the library already implements these.

Simplify your life with macros

If you just want to serialize/deserialize some structs, the to_json/from_json functions can be a lot of boilerplate. There are several macros to make your life easier as long as you want to use a JSON object as serialization.

Which macro to choose depends on whether private member variables need to be accessed, a deserialization is needed, missing values should yield an error or should be replaced by default values, and if derived classes are used. See this overview to choose the right one for your use case.

Example usage of macros

The to_json/from_json functions for the person struct above can be created with NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE. In all macros, the first parameter is the name of the class/struct, and all remaining parameters name the members.

namespace ns {
    NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(person, name, address, age)
}

If you want to inherit the person struct and add a field to it, it can be done with:

namespace ns {
    struct person_derived : person {
        std::string email;
    };
    
    NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(person_derived, person, email)
}

Here is another example with private members, where NLOHMANN_DEFINE_TYPE_INTRUSIVE is needed:

namespace ns {
    class address {
      private:
        std::string street;
        int housenumber;
        int postcode;
  
      public:
        NLOHMANN_DEFINE_TYPE_INTRUSIVE(address, street, housenumber, postcode)
    };
}

Or in case if you use some naming convention that you do not want to expose to JSON:

namespace ns {
    class address {
      private:
        std::string m_street;
        int m_housenumber;
        int m_postcode;

      public:
        NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_NAMES(address, "street", m_street,
                                                           "housenumber", m_housenumber,
                                                           "postcode", m_postcode)
    };
}

How do I convert third-party types?

This requires a bit more advanced technique. But first, let's see how this conversion mechanism works:

The library uses JSON Serializers to convert types to JSON. The default serializer for nlohmann::json is nlohmann::adl_serializer (ADL means Argument-Dependent Lookup).

It is implemented like this (simplified):

template <typename T>
struct adl_serializer {
    static void to_json(json& j, const T& value) {
        // calls the "to_json" method in T's namespace
    }

    static void from_json(const json& j, T& value) {
        // same thing, but with the "from_json" method
    }
};

This serializer works fine when you have control over the type's namespace. However, what about boost::optional or std::filesystem::path (C++17)? Hijacking the boost namespace is pretty bad, and it's illegal to add something other than template specializations to std...

To solve this, you need to add a specialization of adl_serializer to the nlohmann namespace, here's an example:

// partial specialization (full specialization works too)
namespace nlohmann {
    template <typename T>
    struct adl_serializer<boost::optional<T>> {
        static void to_json(json& j, const boost::optional<T>& opt) {
            if (opt == boost::none) {
                j = nullptr;
            } else {
              j = *opt; // this will call adl_serializer<T>::to_json which will
                        // find the free function to_json in T's namespace!
            }
        }

        static void from_json(const json& j, boost::optional<T>& opt) {
            if (j.is_null()) {
                opt = boost::none;
            } else {
                opt = j.get<T>(); // same as above, but with
                                  // adl_serializer<T>::from_json
            }
        }
    };
}

How can I use `get()` for non-default constructible/non-copyable types?

There is a way if your type is MoveConstructible. You will need to specialize the adl_serializer as well, but with a special from_json overload:

struct move_only_type {
    move_only_type() = delete;
    move_only_type(int ii): i(ii) {}
    move_only_type(const move_only_type&) = delete;
    move_only_type(move_only_type&&) = default;

    int i;
};

namespace nlohmann {
    template <>
    struct adl_serializer<move_only_type> {
        // note: the return type is no longer 'void', and the method only takes
        // one argument
        static move_only_type from_json(const json& j) {
            return {j.get<int>()};
        }

        // Here's the catch! You must provide a to_json method! Otherwise, you
        // will not be able to convert move_only_type to json, since you fully
        // specialized adl_serializer on that type
        static void to_json(json& j, move_only_type t) {
            j = t.i;
        }
    };
}

Can I write my own serializer? (Advanced use)

Yes. You might want to take a look at unit-udt.cpp in the test suite, to see a few examples.

If you write your own serializer, you'll need to do a few things:

use a different basic_json alias than nlohmann::json (the last template parameter of basic_json is the JSONSerializer)
use your basic_json alias (or a template parameter) in all your to_json/from_json methods
use nlohmann::to_json and nlohmann::from_json when you need ADL

Here is an example, without simplifications, that only accepts types with a size <= 32, and uses ADL.

// You should use void as a second template argument
// if you don't need compile-time checks on T
template<typename T, typename SFINAE = typename std::enable_if<sizeof(T) <= 32>::type>
struct less_than_32_serializer {
    template <typename BasicJsonType>
    static void to_json(BasicJsonType& j, T value) {
        // we want to use ADL, and call the correct to_json overload
        using nlohmann::to_json; // this method is called by adl_serializer,
                                 // this is where the magic happens
        to_json(j, value);
    }

    template <typename BasicJsonType>
    static void from_json(const BasicJsonType& j, T& value) {
        // same thing here
        using nlohmann::from_json;
        from_json(j, value);
    }
};

Be very careful when reimplementing your serializer, you can stack overflow if you don't pay attention:

template <typename T, void>
struct bad_serializer
{
    template <typename BasicJsonType>
    static void to_json(BasicJsonType& j, const T& value) {
      // this calls BasicJsonType::json_serializer<T>::to_json(j, value)
      // if BasicJsonType::json_serializer == bad_serializer ... oops!
      j = value;
    }

    template <typename BasicJsonType>
    static void to_json(const BasicJsonType& j, T& value) {
      // this calls BasicJsonType::json_serializer<T>::from_json(j, value)
      // if BasicJsonType::json_serializer == bad_serializer ... oops!
      value = j.get<T>(); // oops!
    }
};

Specializing enum conversion

By default, enum values are serialized to JSON as integers. In some cases, this could result in undesired behavior. If an enum is modified or re-ordered after data has been serialized to JSON, the later deserialized JSON data may be undefined or a different enum value than was originally intended.

It is possible to more precisely specify how a given enum is mapped to and from JSON as shown below:

// example enum type declaration
enum TaskState {
    TS_STOPPED,
    TS_RUNNING,
    TS_COMPLETED,
    TS_INVALID=-1,
};

// map TaskState values to JSON as strings
NLOHMANN_JSON_SERIALIZE_ENUM( TaskState, {
    {TS_INVALID, nullptr},
    {TS_STOPPED, "stopped"},
    {TS_RUNNING, "running"},
    {TS_COMPLETED, "completed"},
})

The NLOHMANN_JSON_SERIALIZE_ENUM() macro declares a set of to_json() / from_json() functions for type TaskState while avoiding repetition and boilerplate serialization code.

Usage:

// enum to JSON as string
json j = TS_STOPPED;
assert(j == "stopped");

// json string to enum
json j3 = "running";
assert(j3.get<TaskState>() == TS_RUNNING);

// undefined json value to enum (where the first map entry above is the default)
json jPi = 3.14;
assert(jPi.get<TaskState>() == TS_INVALID);

Just as in Arbitrary Type Conversions above,

NLOHMANN_JSON_SERIALIZE_ENUM() MUST be declared in your enum type's namespace (which can be the global namespace), or the library will not be able to locate it, and it will default to integer serialization.
It MUST be available (e.g., proper headers must be included) everywhere you use the conversions.

Other Important points:

When using get<ENUM_TYPE>(), undefined JSON values will default to the first pair specified in your map. Select this default pair carefully.
If an enum or JSON value is specified more than once in your map, the first matching occurrence from the top of the map will be returned when converting to or from JSON.

Binary formats (BSON, CBOR, MessagePack, UBJSON, and BJData)

Though JSON is a ubiquitous data format, it is not a very compact format suitable for data exchange, for instance over a network. Hence, the library supports BSON (Binary JSON), CBOR (Concise Binary Object Representation), MessagePack, UBJSON (Universal Binary JSON Specification) and BJData (Binary JData) to efficiently encode JSON values to byte vectors and to decode such vectors.

// create a JSON value
json j = R"({"compact": true, "schema": 0})"_json;

// serialize to BSON
std::vector<std::uint8_t> v_bson = json::to_bson(j);

// 0x1B, 0x00, 0x00, 0x00, 0x08, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x63, 0x74, 0x00, 0x01, 0x10, 0x73, 0x63, 0x68, 0x65, 0x6D, 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00

// roundtrip
json j_from_bson = json::from_bson(v_bson);

// serialize to CBOR
std::vector<std::uint8_t> v_cbor = json::to_cbor(j);

// 0xA2, 0x67, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x63, 0x74, 0xF5, 0x66, 0x73, 0x63, 0x68, 0x65, 0x6D, 0x61, 0x00

// roundtrip
json j_from_cbor = json::from_cbor(v_cbor);

// serialize to MessagePack
std::vector<std::uint8_t> v_msgpack = json::to_msgpack(j);

// 0x82, 0xA7, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x63, 0x74, 0xC3, 0xA6, 0x73, 0x63, 0x68, 0x65, 0x6D, 0x61, 0x00

// roundtrip
json j_from_msgpack = json::from_msgpack(v_msgpack);

// serialize to UBJSON
std::vector<std::uint8_t> v_ubjson = json::to_ubjson(j);

// 0x7B, 0x69, 0x07, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x63, 0x74, 0x54, 0x69, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6D, 0x61, 0x69, 0x00, 0x7D

// roundtrip
json j_from_ubjson = json::from_ubjson(v_ubjson);

The library also supports binary types from BSON, CBOR (byte strings), and MessagePack (bin, ext, fixext). They are stored by default as std::vector<std::uint8_t> to be processed outside the library.

// CBOR byte string with payload 0xCAFE
std::vector<std::uint8_t> v = {0x42, 0xCA, 0xFE};

// read value
json j = json::from_cbor(v);

// the JSON value has type binary
j.is_binary(); // true

// get reference to stored binary value
auto& binary = j.get_binary();

// the binary value has no subtype (CBOR has no binary subtypes)
binary.has_subtype(); // false

// access std::vector<std::uint8_t> member functions
binary.size(); // 2
binary[0]; // 0xCA
binary[1]; // 0xFE

// set subtype to 0x10
binary.set_subtype(0x10);

// serialize to MessagePack
auto cbor = json::to_msgpack(j); // 0xD5 (fixext2), 0x10, 0xCA, 0xFE

Customers

The library is used in multiple projects, applications, operating systems, etc. The list below is not exhaustive, but the result of an internet search. If you know further customers of the library, please let me know, see contact.

Supported compilers

Though it's 2026 already, the support for C++11 is still a bit sparse. Currently, the following compilers are known to work:

GCC 4.8 - 14.2 (and possibly later)
Clang 3.4 - 21.0 (and possibly later)
Apple Clang 9.1 - 16.0 (and possibly later)
Intel C++ Compiler 17.0.2 (and possibly later)
Nvidia CUDA Compiler 11.0.221 (and possibly later)
Microsoft Visual C++ 2015 / Build Tools 14.0.25123.0 (and possibly later)
Microsoft Visual C++ 2017 / Build Tools 15.5.180.51428 (and possibly later)
Microsoft Visual C++ 2019 / Build Tools 16.3.1+1def00d3d (and possibly later)
Microsoft Visual C++ 2022 / Build Tools 19.30.30709.0 (and possibly later)

I would be happy to learn about other compilers/versions.

Please note:

GCC 4.8 has a bug 57824: multiline raw strings cannot be the arguments to macros. Don't use multiline raw strings directly in macros with this compiler.
Android defaults to using very old compilers and C++ libraries. To fix this, add the following to your Application.mk. This will switch to the LLVM C++ library, the Clang compiler, and enable C++11 and other features disabled by default.
```
APP_STL := c++_shared
NDK_TOOLCHAIN_VERSION := clang3.6
APP_CPPFLAGS += -frtti -fexceptions
```
The code compiles successfully with Android NDK, Revision 9 - 11 (and possibly later) and CrystaX's Android NDK version 10.
For GCC running on MinGW or Android SDK, the error 'to_string' is not a member of 'std' (or similarly, for strtod or strtof) may occur. Note this is not an issue with the code, but rather with the compiler itself. On Android, see above to build with a newer environment. For MinGW, please refer to this site and this discussion for information on how to fix this bug. For Android NDK using APP_STL := gnustl_static, please refer to this discussion.
Unsupported versions of GCC and Clang are rejected by #error directives. This can be switched off by defining JSON_SKIP_UNSUPPORTED_COMPILER_CHECK. Note that you can expect no support in this case.

See the page quality assurance on the compilers used to check the library in the CI.

Integration

json.hpp is the single required file in single_include/nlohmann or released here. You need to add

#include <nlohmann/json.hpp>

// for convenience
using json = nlohmann::json;

to the files you want to process JSON and set the necessary switches to enable C++11 (e.g., -std=c++11 for GCC and Clang).

You can further use file include/nlohmann/json_fwd.hpp for forward-declarations. The installation of json_fwd.hpp (as part of cmake's install step) can be achieved by setting -DJSON_MultipleHeaders=ON.

CMake

You can also use the nlohmann_json::nlohmann_json interface target in CMake. This target populates the appropriate usage requirements for INTERFACE_INCLUDE_DIRECTORIES to point to the appropriate include directories and INTERFACE_COMPILE_FEATURES for the necessary C++11 flags.

External

To use this library from a CMake project, you can locate it directly with find_package() and use the namespaced imported target from the generated package configuration:

# CMakeLists.txt
find_package(nlohmann_json 3.12.0 REQUIRED)
...
add_library(foo ...)
...
target_link_libraries(foo PRIVATE nlohmann_json::nlohmann_json)

The package configuration file, nlohmann_jsonConfig.cmake, can be used either from an install tree or directly out of the build tree.

Embedded

To embed the library directly into an existing CMake project, place the entire source tree in a subdirectory and call add_subdirectory() in your CMakeLists.txt file:

# Typically you don't care so much for a third party library's tests to be
# run from your own project's code.
set(JSON_BuildTests OFF CACHE INTERNAL "")

# If you only include this third party in PRIVATE source files, you do not
# need to install it when your main project gets installed.
# set(JSON_Install OFF CACHE INTERNAL "")

# Don't use include(nlohmann_json/CMakeLists.txt) since that carries with it
# unintended consequences that will break the build.  It's generally
# discouraged (although not necessarily well documented as such) to use
# include(...) for pulling in other CMake projects anyways.
add_subdirectory(nlohmann_json)
...
add_library(foo ...)
...
target_link_libraries(foo PRIVATE nlohmann_json::nlohmann_json)

Embedded (FetchContent)

Since CMake v3.11, FetchContent can be used to automatically download a release as a dependency at configure time.

Example:

include(FetchContent)

FetchContent_Declare(json URL https://github.com/nlohmann/json/releases/download/v3.12.0/json.tar.xz)
FetchContent_MakeAvailable(json)

target_link_libraries(foo PRIVATE nlohmann_json::nlohmann_json)

Note: It is recommended to use the URL approach described above, which is supported as of version 3.10.0. See https://json.nlohmann.me/integration/cmake/#fetchcontent for more information.

Supporting Both

To allow your project to support either an externally supplied or an embedded JSON library, you can use a pattern akin to the following:

# Top level CMakeLists.txt
project(FOO)
...
option(FOO_USE_EXTERNAL_JSON "Use an external JSON library" OFF)
...
add_subdirectory(thirdparty)
...
add_library(foo ...)
...
# Note that the namespaced target will always be available regardless of the
# import method
target_link_libraries(foo PRIVATE nlohmann_json::nlohmann_json)

# thirdparty/CMakeLists.txt
...
if(FOO_USE_EXTERNAL_JSON)
  find_package(nlohmann_json 3.12.0 REQUIRED)
else()
  set(JSON_BuildTests OFF CACHE INTERNAL "")
  add_subdirectory(nlohmann_json)
endif()
...

thirdparty/nlohmann_json is then a complete copy of this source tree.

Package Managers

Use your favorite package manager to use the library.

Homebrew nlohmann-json
Meson nlohmann_json
Bazel nlohmann_json
Conan nlohmann_json
Spack nlohmann-json
Hunter nlohmann_json
vcpkg nlohmann-json
cget nlohmann/json
Swift Package Manager nlohmann/json
Nuget nlohmann.json
Conda nlohmann_json
MacPorts nlohmann-json
cpm.cmake gh:nlohmann/json
xmake nlohmann_json

The library is part of many package managers. See the documentation for detailed descriptions and examples.

Pkg-config

If you are using bare Makefiles, you can use pkg-config to generate the include flags that point to where the library is installed:

pkg-config nlohmann_json --cflags

License

The class is licensed under the MIT License:

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

The class contains the UTF-8 Decoder from Bjoern Hoehrmann which is licensed under the MIT License (see above). Copyright © 2008-2009 Björn Hoehrmann bjoern@hoehrmann.de
The class contains a slightly modified version of the Grisu2 algorithm from Florian Loitsch which is licensed under the MIT License (see above). Copyright © 2009 Florian Loitsch
The class contains a copy of Hedley from Evan Nemerson which is licensed as CC0-1.0.
The class contains parts of Google Abseil which is licensed under the Apache 2.0 License.

The library is compliant to version 3.3 of the REUSE specification:

Every source file contains an SPDX copyright header.
The full text of all licenses used in the repository can be found in the LICENSES folder.
File .reuse/dep5 contains an overview of all files' copyrights and licenses.
Run pipx run reuse lint to verify the project's REUSE compliance and pipx run reuse spdx to generate a SPDX SBOM.

Contact

If you have questions regarding the library, I would like to invite you to open an issue at GitHub. Please describe your request, problem, or question as detailed as possible, and also mention the version of the library you are using as well as the version of your compiler and operating system. Opening an issue at GitHub allows other users and contributors to this library to collaborate. For instance, I have little experience with MSVC, and most issues in this regard have been solved by a growing community. If you have a look at the closed issues, you will see that we react quite timely in most cases.

Only if your request would contain confidential information, please send me an email. For encrypted messages, please use this key.

Security

Commits by Niels Lohmann and releases are signed with this PGP Key.

Thanks

I deeply appreciate the help of the following people.

Teemperor implemented CMake support and lcov integration, realized escape and Unicode handling in the string parser, and fixed the JSON serialization.
elliotgoodrich fixed an issue with double deletion in the iterator classes.
kirkshoop made the iterators of the class composable to other libraries.
wancw fixed a bug that hindered the class to compile with Clang.
Tomas Åblad found a bug in the iterator implementation.
Joshua C. Randall fixed a bug in the floating-point serialization.
Aaron Burghardt implemented code to parse streams incrementally. Furthermore, he greatly improved the parser class by allowing the definition of a filter function to discard undesired elements while parsing.
Daniel Kopeček fixed a bug in the compilation with GCC 5.0.
Florian Weber fixed a bug in and improved the performance of the comparison operators.
Eric Cornelius pointed out a bug in the handling with NaN and infinity values. He also improved the performance of the string escaping.
易思龙 implemented a conversion from anonymous enums.
kepkin patiently pushed forward the support for Microsoft Visual Studio.
gregmarr simplified the implementation of reverse iterators and helped with numerous hints and improvements. In particular, he pushed forward the implementation of user-defined types.
Caio Luppi fixed a bug in the Unicode handling.
dariomt fixed some typos in the examples.
Daniel Frey cleaned up some pointers and implemented exception-safe memory allocation.
Colin Hirsch took care of a small namespace issue.
Huu Nguyen corrected a variable name in the documentation.
Silverweed overloaded parse() to accept an rvalue reference.
dariomt fixed a subtlety in MSVC type support and implemented the get_ref() function to get a reference to stored values.
ZahlGraf added a workaround that allows compilation using Android NDK.
whackashoe replaced a function that was marked as unsafe by Visual Studio.
406345 fixed two small warnings.
Glen Fernandes noted a potential portability problem in the has_mapped_type function.
Corbin Hughes fixed some typos in the contribution guidelines.
twelsby fixed the array subscript operator, an issue that failed the MSVC build, and floating-point parsing/dumping. He further added support for unsigned integer numbers and implemented better roundtrip support for parsed numbers.
Volker Diels-Grabsch fixed a link in the README file.
msm- added support for American Fuzzy Lop.
Annihil fixed an example in the README file.
Themercee noted a wrong URL in the README file.
Lv Zheng fixed a namespace issue with int64_t and uint64_t.
abc100m analyzed the issues with GCC 4.8 and proposed a partial solution.
zewt added useful notes to the README file about Android.
Róbert Márki added a fix to use move iterators and improved the integration via CMake.
Chris Kitching cleaned up the CMake files.
Tom Needham fixed a subtle bug with MSVC 2015 which was also proposed by Michael K..
Mário Feroldi fixed a small typo.
duncanwerner found a really embarrassing performance regression in the 2.0.0 release.
Damien fixed one of the last conversion warnings.
Thomas Braun fixed a warning in a test case and adjusted MSVC calls in the CI.
Théo DELRIEU patiently and constructively oversaw the long way toward iterator-range parsing. He also implemented the magic behind the serialization/deserialization of user-defined types and split the single header file into smaller chunks.
Stefan fixed a minor issue in the documentation.
Vasil Dimov fixed the documentation regarding conversions from std::multiset.
ChristophJud overworked the CMake files to ease project inclusion.
Vladimir Petrigo made a SFINAE hack more readable and added Visual Studio 17 to the build matrix.
Denis Andrejew fixed a grammar issue in the README file.
Pierre-Antoine Lacaze found a subtle bug in the dump() function.
TurpentineDistillery pointed to std::locale::classic() to avoid too much locale joggling, found some nice performance improvements in the parser, improved the benchmarking code, and realized locale-independent number parsing and printing.
cgzones had an idea how to fix the Coverity scan.
Jared Grubb silenced a nasty documentation warning.
Yixin Zhang fixed an integer overflow check.
Bosswestfalen merged two iterator classes into a smaller one.
Daniel599 helped to get Travis to execute the tests with Clang's sanitizers.
Jonathan Lee fixed an example in the README file.
gnzlbg supported the implementation of user-defined types.
Alexej Harm helped to get the user-defined types working with Visual Studio.
Jared Grubb supported the implementation of user-defined types.
EnricoBilla noted a typo in an example.
Martin Hořeňovský found a way for a 2x speedup for the compilation time of the test suite.
ukhegg found proposed an improvement for the examples section.
rswanson-ihi noted a typo in the README.
Mihai Stan fixed a bug in the comparison with nullptrs.
Tushar Maheshwari added cotire support to speed up the compilation.
TedLyngmo noted a typo in the README, removed unnecessary bit arithmetic, and fixed some -Weffc++ warnings.
Krzysztof Woś made exceptions more visible.
ftillier fixed a compiler warning.
tinloaf made sure all pushed warnings are properly popped.
Fytch found a bug in the documentation.
Jay Sistar implemented a Meson build description.
Henry Lee fixed a warning in ICC and improved the iterator implementation.
Vincent Thiery maintains a package for the Conan package manager.
Steffen fixed a potential issue with MSVC and std::min.
Mike Tzou fixed some typos.
amrcode noted misleading documentation about comparison of floats.
Oleg Endo reduced the memory consumption by replacing <iostream> with <iosfwd>.
dan-42 cleaned up the CMake files to simplify including/reusing of the library.
Nikita Ofitserov allowed for moving values from initializer lists.
Greg Hurrell fixed a typo.
Dmitry Kukovinets fixed a typo.
kbthomp1 fixed an issue related to the Intel OSX compiler.
Markus Werle fixed a typo.
WebProdPP fixed a subtle error in a precondition check.
Alex noted an error in a code sample.
Tom de Geus reported some warnings with ICC and helped to fix them.
Perry Kundert simplified reading from input streams.
Sonu Lohani fixed a small compilation error.
Jamie Seward fixed all MSVC warnings.
Nate Vargas added a Doxygen tag file.
pvleuven helped to fix a warning in ICC.
Pavel helped to fix some warnings in MSVC.
Jamie Seward avoided unnecessary string copies in find() and count().
Mitja fixed some typos.
Jorrit Wronski updated the Hunter package links.
Matthias Möller added a .natvis for the MSVC debug view.
bogemic fixed some C++17 deprecation warnings.
Eren Okka fixed some MSVC warnings.
abolz integrated the Grisu2 algorithm for proper floating-point formatting, allowing more roundtrip checks to succeed.
Vadim Evard fixed a Markdown issue in the README.
zerodefect fixed a compiler warning.
Kert allowed to template the string type in the serialization and added the possibility to override the exceptional behavior.
mark-99 helped fix an ICC error.
Patrik Huber fixed links in the README file.
johnfb found a bug in the implementation of CBOR's indefinite length strings.
Paul Fultz II added a note on the cget package manager.
Wilson Lin made the integration section of the README more concise.
RalfBielig detected and fixed a memory leak in the parser callback.
agrianius allowed dumping JSON to an alternative string type.
Kevin Tonon overworked the C++11 compiler checks in CMake.
Axel Huebl simplified a CMake check and added support for the Spack package manager.
Carlos O'Ryan fixed a typo.
James Upjohn fixed a version number in the compilers section.
Chuck Atkins adjusted the CMake files to the CMake packaging guidelines and provided documentation for the CMake integration.
Jan Schöppach fixed a typo.
martin-mfg fixed a typo.
Matthias Möller removed the dependency from std::stringstream.
agrianius added code to use alternative string implementations.
Daniel599 allowed to use more algorithms with the items() function.
Julius Rakow fixed the Meson include directory and fixed the links to cppreference.com.
Sonu Lohani fixed the compilation with MSVC 2015 in debug mode.
grembo fixed the test suite and re-enabled several test cases.
Hyeon Kim introduced the macro JSON_INTERNAL_CATCH to control the exception handling inside the library.
thyu fixed a compiler warning.
David Guthrie fixed a subtle compilation error with Clang 3.4.2.
Dennis Fischer allowed to call find_package without installing the library.
Hyeon Kim fixed an issue with a double macro definition.
Ben Berman made some error messages more understandable.
zakalibit fixed a compilation problem with the Intel C++ compiler.
mandreyel fixed a compilation problem.
Kostiantyn Ponomarenko added version and license information to the Meson build file.
Henry Schreiner added support for GCC 4.8.
knilch made sure the test suite does not stall when run in the wrong directory.
Antonio Borondo fixed an MSVC 2017 warning.
Dan Gendreau implemented the NLOHMANN_JSON_SERIALIZE_ENUM macro to quickly define an enum/JSON mapping.
efp added line and column information to parse errors.
julian-becker added BSON support.
Pratik Chowdhury added support for structured bindings.
David Avedissian added support for Clang 5.0.1 (PS4 version).
Jonathan Dumaresq implemented an input adapter to read from FILE*.
kjpus fixed a link in the documentation.
Manvendra Singh fixed a typo in the documentation.
ziggurat29 fixed an MSVC warning.
Sylvain Corlay added code to avoid an issue with MSVC.
mefyl fixed a bug when JSON was parsed from an input stream.
Millian Poquet allowed to install the library via Meson.
Michael Behrns-Miller found an issue with a missing namespace.
Nasztanovics Ferenc fixed a compilation issue with libc 2.12.
Andreas Schwab fixed the endian conversion.
Mark-Dunning fixed a warning in MSVC.
Gareth Sylvester-Bradley added operator/ for JSON Pointers.
John-Mark noted a missing header.
Vitaly Zaitsev fixed compilation with GCC 9.0.
Laurent Stacul fixed compilation with GCC 9.0.
Ivor Wanders helped to reduce the CMake requirement to version 3.1.
njlr updated the Buckaroo instructions.
Lion fixed a compilation issue with GCC 7 on CentOS.
Isaac Nickaein improved the integer serialization performance and implemented the contains() function.
past-due suppressed an unfixable warning.
Elvis Oric improved Meson support.
Matěj Plch fixed an example in the README.
Mark Beckwith fixed a typo.
scinart fixed a bug in the serializer.
Patrick Boettcher implemented push_back() and pop_back() for JSON Pointers.
Bruno Oliveira added support for Conda.
Michele Caini fixed links in the README.
Hani documented how to install the library with NuGet.
Mark Beckwith fixed a typo.
yann-morin-1998 helped to reduce the CMake requirement to version 3.1.
Konstantin Podsvirov maintains a package for the MSYS2 software distro.
remyabel added GNUInstallDirs to the CMake files.
Taylor Howard fixed a unit test.
Gabe Ron implemented the to_string method.
Watal M. Iwasaki fixed a Clang warning.
Viktor Kirilov switched the unit tests from Catch to doctest
Juncheng E fixed a typo.
tete17 fixed a bug in the contains function.
Xav83 fixed some cppcheck warnings.
0xflotus fixed some typos.
Christian Deneke added a const version of json_pointer::back.
Julien Hamaide made the items() function work with custom string types.
Evan Nemerson updated fixed a bug in Hedley and updated this library accordingly.
Florian Pigorsch fixed a lot of typos.
Camille Bégué fixed an issue in the conversion from std::pair and std::tuple to json.
Anthony VH fixed a compile error in an enum deserialization.
Yuriy Vountesmery noted a subtle bug in a preprocessor check.
Chen fixed numerous issues in the library.
Antony Kellermann added a CI step for GCC 10.1.
Alex fixed an MSVC warning.
Rainer proposed an improvement in the floating-point serialization in CBOR.
Francois Chabot made performance improvements in the input adapters.
Arthur Sonzogni documented how the library can be included via FetchContent.
Rimas Misevičius fixed an error message.
Alexander Myasnikov fixed some examples and a link in the README.
Hubert Chathi made CMake's version config file architecture-independent.
OmnipotentEntity implemented the binary values for CBOR, MessagePack, BSON, and UBJSON.
ArtemSarmini fixed a compilation issue with GCC 10 and fixed a leak.
Evgenii Sopov integrated the library to the wsjcpp package manager.
Sergey Linev fixed a compiler warning.
Miguel Magalhães fixed the year in the copyright.
Gareth Sylvester-Bradley fixed a compilation issue with MSVC.
Alexander “weej” Jones fixed an example in the README.
Antoine Cœur fixed some typos in the documentation.
jothepro updated links to the Hunter package.
Dave Lee fixed a link in the README.
Joël Lamotte added instruction for using Build2's package manager.
Paul Jurczak fixed an example in the README.
Sonu Lohani fixed a warning.
Carlos Gomes Martinho updated the Conan package source.
Konstantin Podsvirov fixed the MSYS2 package documentation.
Tridacnid improved the CMake tests.
Michael fixed MSVC warnings.
Quentin Barbarat fixed an example in the documentation.
XyFreak fixed a compiler warning.
TotalCaesar659 fixed links in the README.
Tanuj Garg improved the fuzzer coverage for UBSAN input.
AODQ fixed a compiler warning.
jwittbrodt made NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE inline.
pfeatherstone improved the upper bound of arguments of the NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE/NLOHMANN_DEFINE_TYPE_INTRUSIVE macros.
Jan Procházka fixed a bug in the CBOR parser for binary and string values.
T0b1-iOS fixed a bug in the new hash implementation.
Matthew Bauer adjusted the CBOR writer to create tags for binary subtypes.
gatopeich implemented an ordered map container for nlohmann::ordered_json.
Érico Nogueira Rolim added support for pkg-config.
KonanM proposed an implementation for the NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE/NLOHMANN_DEFINE_TYPE_INTRUSIVE macros.
Guillaume Racicot implemented string_view support and allowed C++20 support.
Alex Reinking improved CMake support for FetchContent.
Hannes Domani provided a GDB pretty printer.
Lars Wirzenius reviewed the README file.
Jun Jie fixed a compiler path in the CMake scripts.
Ronak Buch fixed typos in the documentation.
Alexander Karzhenkov fixed a move constructor and the Travis builds.
Leonardo Lima added CPM.Cmake support.
Joseph Blackman fixed a warning.
Yaroslav updated doctest and implemented unit tests.
Martin Stump fixed a bug in the CMake files.
Jaakko Moisio fixed a bug in the input adapters.
bl-ue fixed some Markdown issues in the README file.
William A. Wieselquist fixed an example from the README.
abbaswasim fixed an example from the README.
Remy Jette fixed a warning.
Fraser fixed the documentation.
Ben Beasley updated doctest.
Doron Behar fixed pkg-config.pc.
raduteo fixed a warning.
David Pfahler added the possibility to compile the library without I/O support.
Morten Fyhn Amundsen fixed a typo.
jpl-mac allowed treating the library as a system header in CMake.
Jason Dsouza fixed the indentation of the CMake file.
offa added a link to Conan Center to the documentation.
TotalCaesar659 updated the links in the documentation to use HTTPS.
Rafail Giavrimis fixed the Google Benchmark default branch.
Louis Dionne fixed a conversion operator.
justanotheranonymoususer made the examples in the README more consistent.
Finkman suppressed some -Wfloat-equal warnings.
Ferry Huberts fixed -Wswitch-enum warnings.
Arseniy Terekhin made the GDB pretty-printer robust against unset variable names.
Amir Masoud Abdol updated the Homebrew command as nlohmann/json is now in homebrew-core.
Hallot fixed some -Wextra-semi-stmt warnings.
Giovanni Cerretani fixed -Wunused warnings on JSON_DIAGNOSTICS.
Bogdan Popescu hosts the docset for offline documentation viewers.
Carl Smedstad fixed an assertion error when using JSON_DIAGNOSTICS.
miikka75 provided an important fix to compile C++17 code with Clang 9.
Maarten Becker fixed a warning for shadowed variables.
Cristi Vîjdea fixed typos in the operator[] documentation.
Alex Beregszaszi fixed spelling mistakes in comments.
Dirk Stolle fixed typos in documentation.
Daniel Albuschat corrected the parameter name in the parse documentation.
Prince Mendiratta fixed a link to the FAQ.
Florian Albrechtskirchinger implemented std::string_view support for object keys and made dozens of other improvements.
Qianqian Fang implemented the Binary JData (BJData) format.
pketelsen added macros NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT and NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT.
DarkZeros adjusted to code to not clash with Arduino defines.
flagarde fixed the output of meta() for MSVC.
Giovanni Cerretani fixed a check for std::filesystem.
Dimitris Apostolou fixed a typo.
Ferry Huberts fixed a typo.
Michael Nosthoff fixed a typo.
JungHoon Lee fixed a typo.
Faruk D. fixed the CITATION.CFF file.
Andrea Cocito added a clarification on macro usage to the documentation.
Krzysiek Karbowiak refactored the tests to use CHECK_THROWS_WITH_AS.
Chaoqi Zhang fixed a typo.
ivanovmp fixed a whitespace error.
KsaNL fixed a build error when including <windows.h>.
Andrea Pappacoda moved .pc and .cmake files to share directory.
Wolf Vollprecht added the patch_inplace function.
Jake Zimmerman highlighted common usage patterns in the README file.
NN added the Visual Studio output directory to .gitignore.
Romain Reignier improved the performance of the vector output adapter.
Mike fixed the std::iterator_traits.
Richard Hozák added macro JSON_NO_ENUM to disable default enum conversions.
vakokako fixed tests when compiling with C++20.
Alexander “weej” Jones fixed an example in the README.
Eli Schwartz added more files to the include.zip archive.
Kevin Lu fixed a compilation issue when typedefs with certain names were present.
Trevor Hickey improved the description of an example.
Jef LeCompte updated the year in the README file.
Alexandre Hamez fixed a warning.
Maninderpal Badhan fixed a typo.
kevin-- added a note to an example in the README file.
I fixed a typo.
Gregorio Litenstein fixed the Clang detection.
Andreas Smas added a Doozer badge.
WanCW fixed the string conversion with Clang.
zhaohuaxishi fixed a Doxygen error.
emvivre removed an invalid parameter from CMake.
Tobias Hermann fixed a link in the README file.
Michael fixed a warning.
Ryan Mulder added ensure_ascii to the dump function.
Muri Nicanor fixed the sed discovery in the Makefile.
David Avedissian implemented SFINAE-friendly iterator_traits.
AQNOUCH Mohammed fixed a typo in the README.
Gareth Sylvester-Bradley added operator/= and operator/ to construct JSON pointers.
Michael Macnair added support for afl-fuzz testing.
Berkus Decker fixed a typo in the README.
Illia Polishchuk improved the CMake testing.
Ikko Ashimine fixed a typo.
Raphael Grimm added the possibility to define a custom base class.
tocic fixed typos in the documentation.
Vertexwahn added Bazel build support.
Dirk Stolle fixed typos in the documentation.
DavidKorczynski added a CIFuzz CI GitHub action.
Finkman fixed the debug pretty-printer.
Florian Segginger bumped the years in the README.
haadfida cleaned up the badges of used services.
Arsen Arsenović fixed a build error.
theevilone45 fixed a typo in a CMake file.
Sergei Trofimovich fixed the custom allocator support.
Joyce fixed some security issues in the GitHub workflows.
Nicolas Jakob add vcpkg version badge.
Tomerkm added tests.
No. fixed the use of get<> calls.
taro fixed a typo in the CODEOWNERS file.
Ikko Eltociear Ashimine fixed a typo.
Felix Yan fixed a typo in the README.
HO-COOH fixed a parenthesis in the documentation.
Ivor Wanders fixed the examples to catch exception by const&.
miny1233 fixed a parenthesis in the documentation.
tomalakgeretkal fixed a compilation error.
alferov fixed a compilation error.
Craig Scott fixed a deprecation warning in CMake.
Vyacheslav Zhdanovskiy added macros for serialization-only types.
Mathieu Westphal fixed typos.
scribam fixed the MinGW workflow.
Aleksei Sapitskii added support for Apple's Swift Package Manager.
Benjamin Buch fixed the installation path in CMake.
Colby Haskell clarified the parse error message in case a file cannot be opened.
Juan Carlos Arevalo Baeza fixed the enum conversion.
alferov fixed a version in the documentation.
ss fixed the amalgamation call.
AniketDhemare fixed a version in the documentation.
Philip Müller fixed an example.
Leila Shcheglova fixed a warning in a test.
Alex Prabhat Bara fixed a function name in the documentation.
laterlaugh fixed some typos.
Yuanhao Jia fixed the GDB pretty printer.
Fallen_Breath fixed an example for JSON Pointer.
Nikhil Idiculla fixed some typos.
Griffin Myers updated the Natvis file.
thetimr fixed a typo in the documentation.
Balazs Erseki fixed a URL in the contribution guidelines.
Niccolò Iardella added NLOHMANN_DEFINE_DERIVED_TYPE_* macros.
Borislav Stanimirov allowed overriding the CMake target name.
Captain Crutches made iterator_proxy_value a std::forward_iterator.
Fredrik Sandhei added type conversion support for std::optional.
jh96 added exceptions when nullptr is passed to parse.
Stuart Gorman fixed number parsing when EINTR set in errno.
Dylan Baker generated a pkg-config file that follows the pkg-config conventions.
Tianyi Chen optimized the binary get_number implementation.
peng-wang-cn added type conversion support for multidimensional arrays.
Einars Netlis-Galejs added ONLY_SERIALIZE for NLOHMANN_DEFINE_DERIVED_TYPE_* macros.
Marcel removed alwayslink=True Bazel flag.
Harinath Nampally added diagnostic positions to exceptions.
Nissim Armand Ben Danan fixed NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT with an empty JSON instance.
Michael Valladolid added support for BSON uint64 serialization/deserialization.
Nikhil updated the documentation.
Nebojša Cvetković added support for BJDATA optimized binary array type.
Sushrut Shringarputale added support for diagnostic positions.
kimci86 templated to NLOHMANN_DEFINE_TYPE macros to also support ordered_json.
Richard Topchii added support for VisionOS in the Swift Package Manager.
Robert Chisholm fixed a typo.
zjyhjqs added CPack support.
bitFiedler made GDB pretty printer work with Python 3.8.
Gianfranco Costamagna fixed a compiler warning.
risa2000 made std::filesystem::path conversion to/from UTF-8 encoded string explicit.

Thanks a lot for helping out! Please let me know if I forgot someone.

Used third-party tools

The library itself consists of a single header file licensed under the MIT license. However, it is built, tested, documented, and whatnot using a lot of third-party tools and services. Thanks a lot!

amalgamate.py - Amalgamate C source and header files to create a single header file
American fuzzy lop for fuzz testing
AppVeyor for continuous integration on Windows
Artistic Style for automatic source code indentation
Clang for compilation with code sanitizers
CMake for build automation
Codacy for further code analysis
Coveralls to measure code coverage
Coverity Scan for static analysis
cppcheck for static analysis
doctest for the unit tests
GitHub Changelog Generator to generate the ChangeLog
Google Benchmark to implement the benchmarks
Hedley to avoid re-inventing several compiler-agnostic feature macros
lcov to process coverage information and create an HTML view
libFuzzer to implement fuzz testing for OSS-Fuzz
Material for MkDocs for the style of the documentation site
MkDocs for the documentation site
OSS-Fuzz for continuous fuzz testing of the library (project repository)
Probot for automating maintainer tasks such as closing stale issues, requesting missing information, or detecting toxic comments.
Valgrind to check for correct memory management

Notes

Character encoding

The library supports Unicode input as follows:

Only UTF-8 encoded input is supported, which is the default encoding for JSON according to RFC 8259.
std::u16string and std::u32string can be parsed, assuming UTF-16 and UTF-32 encoding, respectively. These encodings are not supported when reading from files or other input containers.
Other encodings such as Latin-1 or ISO 8859-1 are not supported and will yield parse or serialization errors.
Unicode noncharacters will not be replaced by the library.
Invalid surrogates (e.g., incomplete pairs such as \uDEAD) will yield parse errors.
The strings stored in the library are UTF-8 encoded. When using the default string type (std::string), note that its length/size functions return the number of stored bytes rather than the number of characters or glyphs.
When you store strings with different encodings in the library, calling dump() may throw an exception unless json::error_handler_t::replace or json::error_handler_t::ignore are used as error handlers.
To store wide strings (e.g., std::wstring), you need to convert them to a UTF-8 encoded std::string before, see an example.

Comments in JSON

This library does not support comments by default. It does so for three reasons:

Comments are not part of the JSON specification. You may argue that // or /* */ are allowed in JavaScript, but JSON is not JavaScript.
This was not an oversight: Douglas Crockford wrote on this in May 2012:

I removed comments from JSON because I saw people were using them to hold parsing directives, a practice which would have destroyed interoperability. I know that the lack of comments makes some people sad, but it shouldn't.

Suppose you are using JSON to keep configuration files, which you would like to annotate. Go ahead and insert all the comments you like. Then pipe it through JSMin before handing it to your JSON parser.
It is dangerous for interoperability if some libraries would add comment support while others don't. Please check The Harmful Consequences of the Robustness Principle on this.

However, you can set set parameter ignore_comments to true in the parse function to ignore // or /* */ comments. Comments will then be treated as whitespace.

Trailing commas

The JSON specification does not allow trailing commas in arrays and objects, and hence this library is treating them as parsing errors by default.

Like comments, you can set parameter ignore_trailing_commas to true in the parse function to ignore trailing commas in arrays and objects. Note that a single comma as the only content of the array or object ([,] or {,}) is not allowed, and multiple trailing commas ([1,,]) are not allowed either.

This library does not add trailing commas when serializing JSON data.

For more information, see JSON With Commas and Comments (JWCC).

Order of object keys

By default, the library does not preserve the insertion order of object elements. This is standards-compliant, as the JSON standard defines objects as "an unordered collection of zero or more name/value pairs".

If you do want to preserve the insertion order, you can try the type nlohmann::ordered_json. Alternatively, you can use a more sophisticated ordered map like tsl::ordered_map (integration) or nlohmann::fifo_map (integration).

See the documentation on object order for more information.

Memory Release

We checked with Valgrind and the Address Sanitizer (ASAN) that there are no memory leaks.

If you find that a parsing program with this library does not release memory, please consider the following case, and it may be unrelated to this library.

Your program is compiled with glibc. There is a tunable threshold that glibc uses to decide whether to actually return memory to the system or whether to cache it for later reuse. If in your program you make lots of small allocations and those small allocations are not a contiguous block and are presumably below the threshold, then they will not get returned to the OS. Here is a related issue #1924.

Further notes

The code contains numerous debug assertions which can be switched off by defining the preprocessor macro NDEBUG, see the documentation of assert. In particular, note operator[] implements unchecked access for const objects: If the given key is not present, the behavior is undefined (think of a dereferenced null pointer) and yields an assertion failure if assertions are switched on. If you are not sure whether an element in an object exists, use checked access with the at() function. Furthermore, you can define JSON_ASSERT(x) to replace calls to assert(x). See the documentation on runtime assertions for more information.
As the exact number type is not defined in the JSON specification, this library tries to choose the best fitting C++ number type automatically. As a result, the type double may be used to store numbers which may yield floating-point exceptions in certain rare situations if floating-point exceptions have been unmasked in the calling code. These exceptions are not caused by the library and need to be fixed in the calling code, such as by re-masking the exceptions prior to calling library functions.
The code can be compiled without C++ runtime type identification features; that is, you can use the -fno-rtti compiler flag.
Exceptions are used widely within the library. They can, however, be switched off with either using the compiler flag -fno-exceptions or by defining the symbol JSON_NOEXCEPTION. In this case, exceptions are replaced by abort() calls. You can further control this behavior by defining JSON_THROW_USER (overriding throw), JSON_TRY_USER (overriding try), and JSON_CATCH_USER (overriding catch). Note that JSON_THROW_USER should leave the current scope (e.g., by throwing or aborting), as continuing after it may yield undefined behavior. Note the explanatory what() string of exceptions is not available for MSVC if exceptions are disabled, see #2824. See the documentation of exceptions for more information.

Execute unit tests

To compile and run the tests, you need to execute

mkdir build
cd build
cmake .. -DJSON_BuildTests=On
cmake --build .
ctest --output-on-failure

Note that during the ctest stage, several JSON test files are downloaded from an external repository. If policies forbid downloading artifacts during testing, you can download the files yourself and pass the directory with the test files via -DJSON_TestDataDirectory=path to CMake. Then, no Internet connectivity is required. See issue #2189 for more information.

If the testdata is not found, several test suites will fail like this:

===============================================================================
json/tests/src/make_test_data_available.hpp:21:
TEST CASE:  check test suite is downloaded

json/tests/src/make_test_data_available.hpp:23: FATAL ERROR: REQUIRE( utils::check_testsuite_downloaded() ) is NOT correct!
  values: REQUIRE( false )
  logged: Test data not found in 'json/cmake-build-debug/json_test_data'.
          Please execute target 'download_test_data' before running this test suite.
          See <https://github.com/nlohmann/json#execute-unit-tests> for more information.

===============================================================================

In case you have downloaded the library rather than checked out the code via Git, test cmake_fetch_content_configure will fail. Please execute ctest -LE git_required to skip these tests. See issue #2189 for more information.

Some tests are requiring network to be properly execute. They are labeled as git_required. Please execute ctest -LE git_required to skip these tests. See issue #4851 for more information.

Some tests change the installed files and hence make the whole process not reproducible. Please execute ctest -LE not_reproducible to skip these tests. See issue #2324 for more information. Furthermore, assertions must be switched off to ensure reproducible builds (see discussion 4494).

Note you need to call cmake -LE "not_reproducible|git_required" to exclude both labels. See issue #2596 for more information.

As Intel compilers use unsafe floating point optimization by default, the unit tests may fail. Use flag /fp:precise then.

kvcache-ai/Mooncake

Mooncake is the serving platform for Kimi, a leading LLM service provided by Moonshot AI.

A KVCache-centric Disaggregated Architecture for LLM Serving

Mooncake is the serving platform for Kimi, a leading LLM service provided by Moonshot AI. Now both the Transfer Engine and Mooncake Store are open-sourced! This repository also hosts its technical report and the open-sourced traces.

🔄 Updates

May 7, 2026: 🚀 vLLM officially features Mooncake Store — a deep dive into how Mooncake's distributed KVCache engine supercharges vLLM inference with high-throughput, memory-efficient, cross-instance KV cache sharing!
Apr 29, 2026: SGLang introduces RDMA-based P2P weight transfer for large-scale distributed RL using Mooncake TransferEngine, achieving 7x faster weight updates for the 1T-parameter Kimi-K2 model (53s → 7.2s) with zero-copy RDMA transfer across thousands of GPUs.
Mar 19, 2026: TorchSpec: Speculative Decoding Training at Scale is open sourced, using Mooncake to decouple inference and training via efficient hidden states management.
Mar 5, 2026: LightX2V now supports disaggregated deployment based on Mooncake, enabling encoder/transformer service decoupling with Mooncake Transfer Engine for high-performance cross-device and cross-machine data transfer.
Feb 25, 2026: SGLang merged Encoder Global Cache Manager, introducing a Mooncake-powered global multimodal embedding cache that enables cross-instance sharing of ViT embeddings to avoid redundant GPU computation.
Feb 24, 2026: vLLM-Omni introduces disaggregated inference connectors with support for both MooncakeStoreConnector and MooncakeTransferEngineConnector for multi-node omni-modality pipelines.
Feb 12, 2026: Mooncake Joins PyTorch Ecosystem We are thrilled to announce that Mooncake has officially joined the PyTorch Ecosystem!
Jan 28, 2026: FlexKV, a distributed KV store and cache system from Tencent and NVIDIA in collaboration with the community, now supports distributed KVCache reuse with the Mooncake Transfer Engine.
Dec 27, 2025: Collaboration with ROLL! Check out the paper here.
Dec 23, 2025: SGLang introduces Encode-Prefill-Decode (EPD) Disaggregation with Mooncake as a transfer backend. This integration allows decoupling compute-intensive multimodal encoders (e.g., Vision Transformers) from language model nodes, utilizing Mooncake's RDMA engine for zero-copy transfer of large multimodal embeddings.
Dec 19, 2025: Mooncake Transfer Engine has been integrated into TensorRT LLM for KVCache transfer in PD-disaggregated inference.
Dec 19, 2025: Mooncake Transfer Engine has been directly integrated into vLLM v1 as a KV Connector in PD-disaggregated setups.
Nov 07, 2025: RBG + SGLang HiCache + Mooncake, a role-based out-of-the-box solution for cloud native deployment, which is elastic, scalable, and high-performance.
Sept 18, 2025: Mooncake Store empowers vLLM Ascend by serving as the distributed KV cache pool backend.
Sept 10, 2025: SGLang officially supports Mooncake Store as a hierarchical KV caching storage backend. The integration extends RadixAttention with multi-tier KV cache storage across device, host, and remote storage layers.
Sept 10, 2025: The official & high-performance version of Mooncake P2P Store is open-sourced as checkpoint-engine. It has been successfully applied in K1.5 and K2 production training, updating Kimi-K2 model (1T parameters) across thousands of GPUs in ~20s.
Aug 23, 2025: xLLM high-performance inference engine builds hybrid KV cache management based on Mooncake, supporting global KV cache management with intelligent offloading and prefetching.
Aug 18, 2025: vLLM-Ascend integrates Mooncake Transfer Engine for KV cache register and disaggregate prefill, enabling efficient distributed inference on Ascend NPUs.
Jul 20, 2025: Mooncake powers the deployment of Kimi K2 on 128 H200 GPUs with PD disaggregation and large-scale expert parallelism, achieving 224k tokens/sec prefill throughput and 288k tokens/sec decode throughput.
Jun 20, 2025: Mooncake becomes a PD disaggregation backend for LMDeploy.
May 9, 2025: NIXL officially supports Mooncake Transfer Engine as a backend plugin.
May 8, 2025: Mooncake x LMCache unite to pioneer KVCache-centric LLM serving system.
May 5, 2025: Supported by Mooncake Team, SGLang release guidance to deploy DeepSeek with PD Disaggregation on 96 H100 GPUs.
Apr 22, 2025: LMCache officially supports Mooncake Store as a remote connector.
Apr 10, 2025: SGLang officially supports Mooncake Transfer Engine for disaggregated prefilling and KV cache transfer.
Mar 7, 2025: We open-sourced the Mooncake Store, a distributed KVCache based on Transfer Engine. vLLM's xPyD disaggregated prefilling & decoding based on Mooncake Store will be released soon.
Feb 25, 2025: Mooncake receives the Best Paper Award at FAST 2025!
Feb 21, 2025: The updated traces used in our FAST'25 paper have been released.
Dec 16, 2024: vLLM officially supports Mooncake Transfer Engine for disaggregated prefilling and KV cache transfer.
Nov 28, 2024: We open-sourced the Transfer Engine, the central component of Mooncake. We also provide two demonstrations of Transfer Engine: a P2P Store and vLLM integration.
July 9, 2024: We open-sourced the trace as a JSONL file.
June 27, 2024: We present a series of Chinese blogs with more discussions on zhihu 1, 2, 3, 4, 5, 6, 7.
June 26, 2024: Initial technical report release.

🎉 Overview

Mooncake features a KVCache-centric disaggregated architecture that separates the prefill and decoding clusters. It also leverages the underutilized CPU, DRAM, and SSD resources of the GPU cluster to implement a disaggregated KVCache pool.

The core of Mooncake is its KVCache-centric scheduler, which balances maximizing overall effective throughput while meeting latency-related Service Level Objectives (SLOs). Unlike traditional studies that assume all requests will be processed, Mooncake faces challenges in highly overloaded scenarios. To mitigate these, we developed a prediction-based early rejection policy. Experiments show that Mooncake excels in long-context scenarios. Compared to the baseline method, Mooncake can achieve up to a 525% increase in throughput in certain simulated scenarios while adhering to SLOs. Under real workloads, Mooncake’s innovative architecture enables Kimi to handle 75% more requests.

🧩 Components

Mooncake Core Component: Transfer Engine (TE) The core of Mooncake is the Transfer Engine (TE), which provides a unified interface for batched data transfer across various storage devices and network links. Supporting multiple protocols including TCP, RDMA, CXL/shared-memory, and NVMe over Fabric (NVMe-of), TE is designed to enable fast and reliable data transfer for AI workloads. Compared to Gloo (used by Distributed PyTorch) and traditional TCP, TE achieves significantly lower I/O latency, making it a superior solution for efficient data transmission.

P2P Store and Mooncake Store Both P2P Store and Mooncake Store are built on the Transfer Engine and provide key/value caching for different scenarios. P2P Store focuses on sharing temporary objects (e.g., checkpoint files) across nodes in a cluster, preventing bandwidth saturation on a single machine. Mooncake Store, on the other hand, supports distributed pooled KVCache, specifically designed for XpYd disaggregation to enhance resource utilization and system performance.

Mooncake Integration with Leading LLM Inference Systems Mooncake has been seamlessly integrated with several popular large language model (LLM) inference systems. Through collaboration with the vLLM and SGLang teams, Mooncake now officially supports prefill-decode disaggregation. By leveraging the high-efficiency communication capabilities of RDMA devices, Mooncake significantly improves inference efficiency in prefill-decode disaggregation scenarios, providing robust technical support for large-scale distributed inference tasks. In addition, Mooncake has been successfully integrated with SGLang's Hierarchical KV Caching, vLLM's prefill serving, and LMCache, augmenting KV cache management capabilities across large-scale inference scenarios.

Elastic Expert Parallelism Support Mooncake adds elasticity and fault tolerance support for MoE model inference, enabling inference systems to remain responsive and recoverable in the event of GPU failures or changes in resource configuration. This functionality includes automatic faulty rank detection and can work with the EPLB module to dynamically route tokens to healthy ranks during inference.

Tensor-Centric Ecosystem Mooncake establishes a full-stack, Tensor-oriented AI infrastructure where Tensors serve as the fundamental data carrier. The ecosystem spans from the Transfer Engine, which accelerates Tensor data movement across heterogeneous storage (DRAM/VRAM/NVMe), to the P2P Store and Mooncake Store for distributed management of Tensor objects (e.g., Checkpoints and KVCache), up to the Mooncake Backend enabling Tensor-based elastic distributed computing. This architecture is designed to maximize Tensor processing efficiency for large-scale model inference and training.

🖥️ Supported Hardware

Mooncake supports heterogeneous accelerators, NICs, and specialized transport paths. The summary below focuses on runtime and transport coverage that is already exposed through build options, documented protocols, or dedicated examples in this repository.

_Huawei

_Cambricon

_{Moore Threads}

_MetaX

_T-Head

_NVIDIA

_AMD

_{Alibaba Cloud}

_AWS

Accelerator runtimes

Vendor / Platform	Hardware / Runtime	Current support in Mooncake	How it is exposed
Huawei Ascend	Ascend NPUs	Supported	`-DUSE_ASCEND=ON`, `-DUSE_ASCEND_DIRECT=ON`, `-DUSE_UBSHMEM=ON`, `-DUSE_ASCEND_HETEROGENEOUS=ON`; covers HCCL transport, Ascend Direct transport, UBShmem transport, and heterogeneous Ascend-GPU transport
Cambricon	MLU + Neuware	Supported	`-DUSE_MLU=ON`; MLU memory detection, topology discovery, and registration reuse the standard `rdma` data path
Moore Threads	MUSA GPUs	Supported	`-DUSE_MUSA=ON`; accelerator-aware data transfer with MUSA runtime integration
MetaX (Muxi)	MACA GPUs	Supported	`-DUSE_MACA=ON`; source build support through the MACA SDK
T-Head	PPU / Barex	Supported	T-Head PPU deployments are represented here through Barex-based transport support
NVIDIA	CUDA GPUs / NVLink	Supported	`-DUSE_CUDA=ON`, `-DUSE_INTRA_NVLINK=ON`, `-DUSE_MNNVL=ON`; covers CUDA memory, GPUDirect RDMA, GPUDirect Storage, intra-node NVLink, and multi-node NVLink
AMD	ROCm / HIP GPUs	Supported	`-DUSE_HIP=ON`; HIP transport for AMD GPU communication

Network and fabric support

Vendor / Fabric	Hardware / Transport	Current support in Mooncake	How it is exposed
Alibaba Cloud	eRDMA NICs	Supported	`rdma` data path with eRDMA devices such as `erdma_0`; the build also enables `CONFIG_ERDMA`
Standard RDMA ecosystem	InfiniBand / RoCE NICs	Supported	Available through the standard `rdma` protocol path with topology-aware NIC selection
AWS	Elastic Fabric Adapter (EFA)	Supported	`-DUSE_EFA=ON`; EFA transport built on libfabric SRD
Storage disaggregation	NVMe-oF	Supported	Enabled with `-DUSE_NVMEOF=ON`
Memory pooling	CXL	Supported	Enabled with `-DUSE_CXL=ON`
Baseline networking	TCP/IP	Supported	`tcp` works in all environments

Specialized transport paths

Transport path	Current support in Mooncake	How it is exposed
Ascend HCCL transport	Supported	Enabled by `-DUSE_ASCEND=ON`; examples use `hccl` for Ascend NPU data movement
Ascend Direct transport	Supported	Enabled by `-DUSE_ASCEND_DIRECT=ON`; dedicated Ascend Direct examples and docs are included
UBShmem transport	Supported	Enabled by `-DUSE_UBSHMEM=ON`; Transfer Engine examples accept `--protocol=ubshmem`
Heterogeneous Ascend transport	Supported	Enabled by `-DUSE_ASCEND_HETEROGENEOUS=ON`; used for Ascend-GPU heterogeneous transfer
Barex transport	Supported	Enabled by `-DUSE_BAREX=ON`; documented as the `barex` advanced transport
Sunrise Transport	Supported	Included here as an additional specialized transport path to reflect current hardware support positioning
T-Head PPU / Barex	Supported	Barex-based transport coverage is available for T-Head PPU deployments

🔥 Show Cases

Use Transfer Engine Standalone (Guide)

Transfer Engine is a high-performance data transfer framework. Transfer Engine provides a unified interface to transfer data from DRAM, VRAM or NVMe, while the technical details related to hardware are hidden. Transfer Engine supports multiple communication protocols including TCP, RDMA (InfiniBand/RoCEv2/eRDMA/NVIDIA GPUDirect), AWS EFA, NVMe over Fabric (NVMe-of), NVLink, HIP, Barex, CXL, and Ascend-family transports. When built with the corresponding runtime, Transfer Engine can also detect and route accelerator memory on CUDA, MUSA, HIP, MACA, Cambricon MLU, and Ascend-enabled environments. For a complete list of supported protocols and configuration guide, see the Supported Protocols Documentation.

Highlights

Efficient use of multiple RDMA NIC devices. Transfer Engine supports the use of multiple RDMA NIC devices to achieve the aggregation of transfer bandwidth.
Topology aware path selection. Transfer Engine can select optimal devices based on the location (NUMA affinity, etc.) of both source and destination.
More robust against temporary network errors. Once transmission fails, Transfer Engine will try to use alternative paths for data delivery automatically.

Performance

With 40 GB of data (equivalent to the size of the KVCache generated by 128k tokens in the LLaMA3-70B model), Mooncake Transfer Engine delivers up to 87 GB/s and 190 GB/s of bandwidth in 4×200 Gbps and 8×400 Gbps RoCE networks respectively, which are about 2.4x and 4.6x faster than the TCP protocol.

P2P Store (Guide)

P2P Store is built on the Transfer Engine and supports sharing temporary objects between peer nodes in a cluster. P2P Store is ideal for scenarios like checkpoint transfer, where data needs to be rapidly and efficiently shared across a cluster. P2P Store has been used in the checkpoint transfer service of Moonshot AI.

Highlights

Decentralized architecture. P2P Store leverages a pure client-side architecture with global metadata managed by the etcd service.
Efficient data distribution. Designed to enhance the efficiency of large-scale data distribution, P2P Store avoids bandwidth saturation issues by allowing replicated nodes to share data directly. This reduces the CPU/RDMA NIC pressures of data providers (e.g., trainers).

Mooncake Store (Guide)

Mooncake Store is a distributed KVCache storage engine specialized for LLM inference based on Transfer Engine. It is the central component of the KVCache-centric disaggregated architecture. The goal of Mooncake Store is to store the reusable KV caches across various locations in an inference cluster. Mooncake Store has been supported in SGLang's Hierarchical KV Caching, vLLM's prefill serving and is now integrated with LMCache to provide enhanced KVCache management capabilities.

Highlights

Multi-replica support: Mooncake Store supports storing multiple data replicas for the same object, effectively alleviating hotspots in access pressure.
High bandwidth utilization: Mooncake Store supports striping and parallel I/O transfer of large objects, fully utilizing multi-NIC aggregated bandwidth for high-speed data reads and writes.

SGLang Integration (Guide)

SGLang officially supports Mooncake Store as a HiCache storage backend. This integration enables scalable KV cache retention and high-performance access for large-scale LLM serving scenarios.

Highlights

Hierarchical KV Caching: Mooncake Store serves as an external storage backend in SGLang's HiCache system, extending RadixAttention with multi-level KV cache storage across device, host, and remote storage layers.
Flexible Cache Management: Supports multiple cache policies including write-through, write-through-selective, and write-back modes, with intelligent prefetching strategies for optimal performance.
Comprehensive Optimizations: Features advanced data plane optimizations including page-first memory layout for improved I/O efficiency, zero-copy mechanisms for reduced memory overhead, GPU-assisted I/O kernels delivering fast CPU-GPU transfers, and layer-wise overlapping for concurrent KV cache loading while computation executes.
Elastic Expert Parallel: Mooncake's collective communication backend and expert parallel kernels are integrated into SGLang to enable fault-tolerant expert parallel inference (sglang#11657).
Significant Performance Gains: The multi-turn benchmark demonstrates substantial performance improvements over the non-HiCache setting. See our benchmark report for more details.
Community Feedback: Effective KV caching significantly reduces TTFT by eliminating redundant and costly re-computation. Integrating SGLang HiCache with the Mooncake service enables scalable KV cache retention and high-performance access. In our evaluation, we tested the DeepSeek-R1-671B model under PD-disaggregated deployment using in-house online requests sampled from a general QA scenario. On average, cache hits achieved an 84% reduction in TTFT compared to full re-computation. – Ant Group

vLLM Integration (Guide v0.2)

To optimize LLM inference, the vLLM community is working on supporting disaggregated prefilling (PR 10502). This feature allows separating the prefill phase from the decode phase in different processes. The vLLM uses nccl and gloo as the transport layer by default, but currently it cannot efficiently decouple both phases in different machines.

We have implemented vLLM integration, which uses Transfer Engine as the network layer instead of nccl and gloo, to support inter-node KVCache transfer (PR 10884). Transfer Engine provides simpler interfaces and more efficient use of RDMA devices.

We will soon release the new vLLM integration based on Mooncake Store, which supports xPyD prefill/decode disaggregation.

Update[Dec 16, 2024]: Here is the latest vLLM Integration (Guide v0.2) that is based on vLLM's main branch.

Performance

By supporting Topology Aware Path Selection and multi-card bandwidth aggregation, Mean TTFT of vLLM with Transfer Engine is up to 25% lower than traditional TCP-based transports. In the future, we will further improve TTFT through GPUDirect RDMA and zero-copy.

Backend/Setting	Output Token Throughput (tok/s)	Total Token Throughput (tok/s)	Mean TTFT (ms)	Median TTFT (ms)	P99 TTFT (ms)
Transfer Engine (RDMA)	12.06	2042.74	1056.76	635.00	4006.59
TCP	12.05	2041.13	1414.05	766.23	6035.36

Click here to access detailed benchmark results.

More advanced features are coming soon, so stay tuned!

🚀 Quick Start

Before using Mooncake

Mooncake is designed and optimized for high-speed RDMA networks. Though Mooncake supports TCP-only data transfer, we strongly recommend users to evaluate the functionality and performance of Mooncake with RDMA network support.

The following need to be installed before running any component of Mooncake:

RDMA Driver & SDK, such as Mellanox OFED.
Python 3.10, virtual environment is recommended.
CUDA 12.1 and above, including NVIDIA GPUDirect Storage Support, if the package is built with -DUSE_CUDA (disabled by default). You may install them from here.
Cambricon Neuware, if the package is built with -DUSE_MLU. By default Mooncake looks for Neuware under NEUWARE_HOME or /usr/local/neuware.

Use Python package

The simplest way to use Mooncake Transfer Engine is using pip:

For CUDA-enabled systems:

CUDA < 13.0

pip install mooncake-transfer-engine

CUDA >= 13.0

pip install mooncake-transfer-engine-cuda13

For non-CUDA systems:

pip install mooncake-transfer-engine-non-cuda

Important

The CUDA version (mooncake-transfer-engine) includes Mooncake-EP and GPU topology detection, requiring CUDA 12.1+.
The non-CUDA version (mooncake-transfer-engine-non-cuda) is for environments without CUDA dependencies.
MLU support is currently available through source builds with -DUSE_MLU=ON; there is no dedicated prebuilt MLU wheel yet.
If users encounter problems such as missing lib*.so, they should uninstall the package they installed and build the binaries manually.

Use Docker image

Mooncake supports Docker-based deployment, see Build Guide in detail.

To produce an image that compiles Mooncake from source, builds the wheel via scripts/build_wheel.sh, and installs that wheel inside the container, use build-wheel.dockerfile:

docker build -f docker/mooncake.Dockerfile \
  --build-arg PYTHON_VERSION=3.10 \
  --build-arg EP_TORCH_VERSIONS="2.9.1" \
  -t mooncake:from-source .

The resulting image already has a virtual environment at /opt/venv with the freshly built wheel installed. Launch it with GPU/RDMA access as needed, for example:

python3 scripts/check_hicache_hugepage_requirements.py \
  --tp-size 4 \
  --hicache-size 64gb \
  --global-segment-size 8gb \
  --arena-pool-size 56gb \
  --available-hugetlb 512gb

sudo sysctl -w vm.nr_hugepages=262144
grep -E 'HugePages_Total|HugePages_Free|Hugepagesize' /proc/meminfo

docker run --gpus all \
  --network host \
  --ipc=host \
  --ulimit memlock=-1 \
  --shm-size=128g \
  -e MC_STORE_USE_HUGEPAGE=1 \
  -e MC_STORE_HUGEPAGE_SIZE=2MB \
  -e MOONCAKE_GLOBAL_SEGMENT_SIZE=8gb \
  -e MC_MMAP_ARENA_POOL_SIZE=56gb \
  -it mooncake:from-source /bin/bash

The 64gb / 56gb values above are tuned examples for large HiCache deployments, not allocator defaults. The arena is off by default. Setting MC_MMAP_ARENA_POOL_SIZE=... explicitly both enables and sizes the arena; if you enable it via gflag instead, the default pool size is 8gb. On smaller hosts, start with 8gb or 16gb and size upward with the helper. Set MC_DISABLE_MMAP_ARENA=1 (also accepts true, yes, or on) instead when you want the baseline direct-mmap() path. Like the arena size itself, this must be set before the first Mooncake mmap-buffer allocation in the process. Arena bring-up is a one-shot lazy init, so after a failed first attempt you need to restart the process to retry with corrected env / hugepage settings. Without MC_STORE_USE_HUGEPAGE=1, the arena may opportunistically try hugepages and then retry on regular pages if HugeTLB is unavailable. When MC_STORE_USE_HUGEPAGE=1 is present, Mooncake instead preserves the strict hugepage contract for both arena and direct-mmap() host-buffer allocation instead of silently downgrading to regular pages.

Note

Make sure you build the image from the repository root so that Git metadata and submodules are available inside the build context.

Build and use binaries

The following are additional dependencies for building Mooncake:

Build essentials, including gcc, g++ (9.4+) and cmake (3.16+).
Go 1.20+, if you want to build with -DWITH_P2P_STORE, -DUSE_ETCD (enabled by default to use etcd as metadata servers), or -DSTORE_USE_ETCD (use etcd for the failover of the store master).
CUDA 12.1 and above, including NVIDIA GPUDirect Storage Support, if the package is built with -DUSE_CUDA. This is NOT included in the dependencies.sh script. You may install them from here.
Cambricon Neuware, if you want to build with -DUSE_MLU. This is NOT included in the dependencies.sh script. Mooncake resolves it from NEUWARE_HOME or /usr/local/neuware by default, and also supports overriding MLU_INCLUDE_DIR / MLU_LIB_DIR during CMake configure.
[Optional] Rust Toolchain and libclang, if you want to build Transfer Engine Rust examples with -DWITH_RUST_EXAMPLE=ON or Mooncake Store Rust bindings with -DWITH_STORE_RUST=ON. This is NOT included in the dependencies.sh script.
[Optional] hiredis, if you want to build with -DUSE_REDIS to use Redis instead of etcd as metadata servers.
[Optional] curl, if you want to build with -DUSE_HTTP to use HTTP instead of etcd as metadata servers.

The build and installation steps are as follows:

Retrieve source code from GitHub repo

git clone https://github.com/kvcache-ai/Mooncake.git
cd Mooncake

Install dependencies
```
bash dependencies.sh
```

Compile Mooncake and examples

mkdir build
cd build
cmake ..
make -j
sudo make install # optional, make it ready to be used by vLLM/SGLang

For Cambricon MLU builds, configure CMake with -DUSE_MLU=ON. For example:

mkdir build
cd build
cmake .. -DUSE_MLU=ON -DNEUWARE_ROOT=/usr/local/neuware
make -j

🛣️ Incoming Milestones

First release of Mooncake and integrate with latest vLLM
Share KV caches across multiple serving engines
User and developer documentation

📦 Open Source Trace

{
    "timestamp": 27482,
    "input_length": 6955,
    "output_length": 52,
    "hash_ids": [46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 2353, 2354]
}
{
    "timestamp": 30535,
    "input_length": 6472,
    "output_length": 26,
    "hash_ids": [46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 2366]
}

The above presents two samples from our trace dataset. The trace includes the timing of request arrivals, the number of input tokens, the number of output tokens, and the remapped block hash. To protect our customers' privacy, we applied several mechanisms to remove user-related information while preserving the dataset's utility for simulated evaluation. More descriptions of the trace (e.g., up to 50% cache hit ratio) can be found in Section 4 of the technical report.

Update[Feb 21, 2025]: The updated traces used in our FAST'25 paper have been released! Please refer to the paper's appendix (found here) for more details.

📑 Citation

Please kindly cite our paper if you find the paper or the traces are useful:

@article{qin2025mooncake_tos,
  author    = {Qin Ruoyu and Li Zheming and He Weiran and Cui Jialei and Tang Heyi and Ren Feng and Ma Teng and Cai Shangming and Zhang Yineng and Zhang Mingxing and Wu Yongwei and Zheng Weimin and Xu Xinran},
  title     = {Mooncake: A KVCache-centric Disaggregated Architecture for LLM Serving},
  year      = {2025},
  publisher = {Association for Computing Machinery},
  address   = {New York, NY, USA},
  issn      = {1553-3077},
  url       = {https://doi.org/10.1145/3773772},
  doi       = {10.1145/3773772},
  journal   = {ACM Trans. Storage},
  month     = {nov},
  keywords  = {Machine learning system, LLM serving, KVCache},
}

@inproceedings{qin2025mooncake,
  author    = {Ruoyu Qin and Zheming Li and Weiran He and Jialei Cui and Feng Ren and Mingxing Zhang and Yongwei Wu and Weimin Zheng and Xinran Xu},
  title     = {Mooncake: Trading More Storage for Less Computation {\textemdash} A {KVCache-centric} Architecture for Serving {LLM} Chatbot},
  booktitle = {23rd USENIX Conference on File and Storage Technologies (FAST 25)},
  year      = {2025},
  isbn      = {978-1-939133-45-8},
  address   = {Santa Clara, CA},
  pages     = {155--170},
  url       = {https://www.usenix.org/conference/fast25/presentation/qin},
  publisher = {USENIX Association},
  month     = {feb},
}

@article{qin2024mooncake_arxiv,
  title  = {Mooncake: A KVCache-centric Disaggregated Architecture for LLM Serving},
  author = {Ruoyu Qin and Zheming Li and Weiran He and Mingxing Zhang and Yongwei Wu and Weimin Zheng and Xinran Xu},
  year   = {2024},
  url    = {https://arxiv.org/abs/2407.00079},
}

NVIDIA/cuda-samples

Samples for CUDA Developers which demonstrates features in CUDA Toolkit

CUDA Samples

Samples for CUDA Developers which demonstrates features in CUDA Toolkit. This version supports CUDA Toolkit 13.2.

Release Notes

This section describes the release notes for the CUDA Samples on GitHub only.

Change Log

Revision History

Getting Started

Prerequisites

Download and install the CUDA Toolkit for your corresponding platform. For system requirements and installation instructions of cuda toolkit, please refer to the Linux Installation Guide, and the Windows Installation Guide.

Getting the CUDA Samples

Using git clone the repository of CUDA Samples using the command below.

git clone https://github.com/NVIDIA/cuda-samples.git

Without using git the easiest way to use these samples is to download the zip file containing the current version by clicking the "Download ZIP" button on the repo page. You can then unzip the entire archive and use the samples.

Building CUDA Samples

The CUDA Samples are built using CMake. Follow the instructions below for building on Linux, Windows, and for cross-compilation to Tegra devices.

Linux

Ensure that CMake (version 3.20 or later) is installed. Install it using your package manager if necessary:

e.g. sudo apt install cmake

Navigate to the root of the cloned repository and create a build directory:

mkdir build && cd build

Configure the project with CMake:

cmake ..

Build the samples:

make -j$(nproc)

Run the samples from their respective directories in the build folder. You can also follow this process from and subdirectory of the samples repo, or from within any individual sample.

Windows

Language services for CMake are available in Visual Studio 2019 version 16.5 or later, and you can directly import the CUDA samples repository from either the root level or from any subdirectory or individual sample.

To build from the command line, open the x64 Native Tools Command Prompt for VS provided with your Visual Studio installation.

Navigate to the root of the cloned repository and create a build directory:

mkdir build && cd build

Configure the project with CMake - for example:

cmake .. -G "Visual Studio 16 2019" -A x64

Open the generated solution file CUDA_Samples.sln in Visual Studio. Build the samples by selecting the desired configuration (e.g., Debug or Release) and pressing F7 (Build Solution).

Run the samples from the output directories specified in Visual Studio.

Enabling On-GPU Debugging

NVIDIA GPUs support on-GPU debugging through cuda-gdb. Enabling this may significantly affect application performance as certain compiler optimizations are disabled in this configuration, hence it's not on by default. Enablement of on-device debugging is controlled via the -G switch to nvcc.

To enable cuda-gdb for samples builds, define the ENABLE_CUDA_DEBUG flag on the CMake command line. For example:

cmake -DENABLE_CUDA_DEBUG=True ...

Platform-Specific Samples

Some CUDA samples are specific to certain platforms, and require passing flags into CMake to enable. In particular, we define the following platform-specific flags:

BUILD_TEGRA - for Tegra-specific samples

To build these samples, set the variables either on the command line or through your CMake GUI. For example:

cmake -DBUILD_TEGRA=True ..

Cross-Compilation for Tegra Platforms

Install the NVIDIA toolchain and cross-compilation environment for Tegra devices as described in the Tegra Development Guide.

Ensure that CMake (version 3.20 or later) is installed.

Navigate to the root of the cloned repository and create a build directory:

mkdir build && cd build

Configure the project with CMake, specifying the Tegra toolchain file. And you can use -DTARGET_FS to point to the target file system root path for necessary include and library files:

cmake .. -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/toolchain-aarch64-linux.cmake -DTARGET_FS=/path/to/target/system/file/system

Build the samples:

make -j$(nproc)

Transfer the built binaries to the Tegra device and execute them there.

Cross Building for Automotive Linux Platforms from the DriveOS Docker containers

To build CUDA samples to the target platform from the DriveOS Docker containers, use the following instructions.

Mount the target Root Filesystem (RFS) in the container so that the CUDA cmake process has the correct paths to CUDA and other system libraries required to build the samples.

Create a temporary directory, <temp> is any temporary directory of your choosing, for example, you can use /drive/temp:

$ mkdir /drive/<temp>

Mount the filesystem by running the following command:

$ mount /drive/drive-linux/filesystem/targetfs-images/dev_nsr_desktop_ubuntu-24.04_thor_rfs.img /drive/temp

Configure the project by running the following cmake command:

$ mkdir build && cd build
$ cmake .. -DBUILD_TEGRA=True \
  -DCMAKE_CUDA_COMPILER=/usr/local/cuda/bin/nvcc \
  -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/toolchain-aarch64-linux.cmake \
  -DTARGET_FS=/drive/temp \
  -DCMAKE_LIBRARY_PATH=/drive/temp/usr/local/cuda-13.1/thor/lib64/ \
  -DCMAKE_INCLUDE_PATH=/drive/temp/usr/local/cuda-13.1/thor/include/

Please note that the following libraries are not pre-installed in the DriveOS dev-nsr target filesystem:

libdrm-dev
Vulkan

This causes the cmake command to throw errors related to the missing files, and as a result, the related samples will not build in later steps. This issue will be addressed in a future DriveOS release.

To build the samples with ignore the error mentioned above, you can use --ignore-errors/--keep-going or comment out the comment out the corresponding add_subdirectory command in the CMakeLists.txt in the parent folder for the samples requiring Vulkan and libdrm_dev:

$ make -j$(nproc) --ignore-errors # or --keep-going

# In cpp/5_Domain_Specific/CMakeList.txt
# add_subdirectory(simpleGL)
# add_subdirectory(simpleVulkan)
# add_subdirectory(simpleVulkanMMAP)

# In cpp/8_Platform_Specific/Tegra/CMakeList.txt
# add_subdirectory(simpleGLES_EGLOutput)

QNX

Cross-compilation for QNX with CMake is supported in the CUDA 13.0 samples release and newer. An example build for the Tegra Thor QNX platform might look like this:

$ mkdir build
$ cd build

QNX_HOST=/path/to/qnx/host \
QNX_TARGET=/path/to/qnx/target \
cmake .. \
-DBUILD_TEGRA=True \
-DCMAKE_CUDA_COMPILER=/usr/local/cuda-safe-13.0/bin/nvcc \
-DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/toolchain-aarch64-qnx.cmake \
-DCMAKE_LIBRARY_PATH=/usr/local/cuda-safe-13.0/thor/targets/aarch64-qnx/lib/stubs/ \
-DCMAKE_INCLUDE_PATH=/usr/local/cuda-safe-13.0/thor/targets/aarch64-qnx/include/

Forward Compatibility

To build samples with new CUDA Toolkit(CUDA 13.0 or later) and UMD(Version 580 or later) and old KMD(Version 550 or earlier)，you need to set the CMAKE_PREFIX_PATH for using new driver library, the command might like this:

cmake -DCMAKE_PREFIX_PATH=/usr/local/cuda/lib64/stubs/ ..

CUDA Python samples

The repository includes Python examples under the python/ directory. These samples are cuda.core–focused: they use CUDA Python, with cuda.core for devices, programs, launches, and memory, alongside NumPy, CuPy, or framework interop where each sample notes.

Layout (same themes as the C++ samples):

Directory	Contents
`python/1_GettingStarted/`	Introductory scripts (e.g. `vectorAdd`, `deviceQuery`, `systemInfo`, image blur with unified memory, NumPy vs CuPy).
`python/2_CoreConcepts/`	Algorithms and techniques (e.g. reductions, histograms, FFT, stream overlap, `memoryResources`, `cudaGraphs`, `jitLtoLinking`, `tmaTensorMap`).
`python/3_FrameworkInterop/`	Integration with PyTorch and TensorFlow.
`python/4_DistributedComputing/`	Multi-GPU, peer-to-peer, and IPC patterns (`ipcMemoryPool`).
`python/Utilities/`	Shared helpers imported by some samples.

How to run: The top-level CMake build does not compile these samples. For each sample, use a Python 3.10+ environment with a matching CUDA Toolkit (the samples target CUDA 13.x and document exact package pins in requirements.txt):

cd python/<category>/<sampleName>
pip install -r requirements.txt
python <sampleScript>.py

Use each sample’s README.md for prerequisites, CLI options, and expected output.

Install Samples

Installation Path Structure

The installation system automatically organizes samples into a structured directory layout based on:

Target Architecture: ${CMAKE_SYSTEM_PROCESSOR}, e.g. x64, aarch64, amd64, etc.
Target OS: linux, windows, darwin, qnx
Build Type: release, debug, etc.

The default installation path is: build/bin/${TARGET_ARCH}/${TARGET_OS}/${BUILD_TYPE}

Examples:

Linux x86_64 Release: build/bin/x64/linux/release
Linux aarch64 Release: build/bin/aarch64/linux/release
Windows amd64 Release: build/bin/amd64/windows/release

Customizing Installation Paths

You can customize the installation location using CMake variables during the configuration step:

CMAKE_INSTALL_PREFIX: Changes the root installation directory (default: build/bin)
```
cmake -DCMAKE_INSTALL_PREFIX=/custom/path ..
```
This will install to: /custom/path/${TARGET_ARCH}/${TARGET_OS}/${BUILD_TYPE}
CUDA_SAMPLES_INSTALL_DIR: Specifies the exact final installation directory (overrides the structured path)
```
cmake -DCUDA_SAMPLES_INSTALL_DIR=/exact/install/path ..
```

Install Samples on Linux

Prerequisites: You must first configure the project with CMake as described in the Building CUDA Samples - Linux or [Building]section.

After configuring and building, install the samples:

cd build/
make install

Install Samples on Windows

Prerequisites: You must first configure the project with CMake as described in the Building CUDA Samples - Windows section.

Using Command Line

After configuring with CMake, build and install from the x64 Native Tools Command Prompt for VS:

cd build
cmake --build . --config Release
cmake --install . --config Release

Note: Replace Release with Debug if you want to install debug builds. For multi-configuration generators (like Visual Studio), the --config flag determines which build type to install.

Using Visual Studio IDE

Alternatively, open the generated solution file CUDA_Samples.sln in Visual Studio:

Select the desired configuration (Release or Debug)
Build the solution (F7 or Build > Build Solution)
Right-click on the INSTALL target under CMakePredefinedTargets in Solution Explorer
Select "Build"

Running All Samples as Tests

It's important to note that the CUDA samples are not intended as a validation suite for CUDA. They do not cover corner cases, they do not completely cover the runtime and driver APIs, are not intended for performance benchmarking, etc. That said, it can sometimes be useful to run all of the samples as a quick sanity check and we provide a script to do so, run_tests.py.

This Python3 script finds all executables in a subdirectory you choose, matching application names with command line arguments specified in test_args.json. It accepts the following command line arguments:

Switch	Purpose	Example
--dir	Specify the root directory to search for executables (recursively)	--dir ./build/cpp
--config	JSON configuration file for executable arguments	--config test_args.json
--output	Output directory for test results (stdout saved to .txt files - directory will be created if it doesn't exist)	--output ./test
--args	Global arguments to pass to all executables (not currently used)	--args arg_1 arg_2 ...
--parallel	Number of applications to execute in parallel.	--parallel 8

Application configurations are loaded from test_args.json and matched against executable names (discarding the .exe extension on Windows).

The script returns 0 on success, or the first non-zero error code encountered during testing on failure. It will also print a condensed list of samples that failed, if any.

There are three primary modes of configuration:

Skip

An executable configured with "skip" will not be executed. These generally rely on having attached graphical displays and are not suited to this kind of automation.

Configuration example:

"fluidsGL": {
    "skip": true
}

You will see:

Skipping fluidsGL (marked as skip in config)

Single Run

For executables to run one time only with arguments, specify each argument as a list entry. Each entry in the JSON file will be appended to the command line, separated by a space.

All applications execute from their current directory, so all paths are relative to the application's location.

Note that if an application needs no arguments, this entry is optional. An executable found without a matching entry in the JSON will just run as ./application from its current directory.

Configuration example:

"ptxgen": {
    "args": [
        "test.ll",
        "-arch=compute_75"
    ]
}

You will see:

Running ptxgen
    Command: ./ptxgen test.ll -arch=compute_75
    Test completed with return code 0

Multiple Runs

For executables to run multiple times with different command line arguments, specify any number of sets of args within a "runs" list.

As with single runs, all applications execute from their current directory, so all paths are relative to the application's location.

Configuration example:

"recursiveGaussian": {
    "runs": [
        {
            "args": [
                "-sigma=10",
                "-file=data/ref_10.ppm"
            ]
        },
        {
            "args": [
                "-sigma=14",
                "-file=data/ref_14.ppm"
            ]
        },
        {
            "args": [
                "-sigma=18",
                "-file=data/ref_18.ppm"
            ]
        },
        {
            "args": [
                "-sigma=22",
                "-file=data/ref_22.ppm"
            ]
        }
    ]
}

You will see:

Running recursiveGaussian (run 1/4)
    Command: ./recursiveGaussian -sigma=10 -file=data/ref_10.ppm
    Test completed with return code 0
Running recursiveGaussian (run 2/4)
    Command: ./recursiveGaussian -sigma=14 -file=data/ref_14.ppm
    Test completed with return code 0
Running recursiveGaussian (run 3/4)
    Command: ./recursiveGaussian -sigma=18 -file=data/ref_18.ppm
    Test completed with return code 0
Running recursiveGaussian (run 4/4)
    Command: ./recursiveGaussian -sigma=22 -file=data/ref_22.ppm
    Test completed with return code 0

Example Usage

Here is an example set of commands to build and test all of the samples.

First, build:

mkdir build
cd build
cmake ..
make -j$(nproc)

Now, return to the samples root directory and run the test script:

cd ..
python3 run_tests.py --output ./test --dir ./build/cpp --config test_args.json

If all applications run successfully, you will see something similar to this (the specific number of samples will depend on your build type and system configuration):

Test Summary:
Ran 199 test runs for 180 executables.
All test runs passed!

If some samples fail, you will see something like this:

Test Summary:
Ran 199 test runs for 180 executables.
Failed runs (2):
  bicubicTexture (run 1/5): Failed (code 1)
  Mandelbrot (run 1/2): Failed (code 1)

You can inspect the stdout logs in the output directory (generally APM_<application_name>.txt or APM_<application_name>.run<n>.txt) to help determine what may have gone wrong from the output logs. Please file issues against the samples repository if you believe a sample is failing incorrectly on your system.

Samples list

0. Introduction

Basic CUDA samples for beginners that illustrate key concepts with using CUDA and CUDA runtime APIs.

1. Utilities

Utility samples that demonstrate how to query device capabilities and measure GPU/CPU bandwidth.

2. Concepts and Techniques

Samples that demonstrate CUDA related concepts and common problem solving techniques.

3. CUDA Features

Samples that demonstrate CUDA Features (Cooperative Groups, CUDA Dynamic Parallelism, CUDA Graphs etc).

4. CUDA Libraries

Samples that demonstrate how to use CUDA platform libraries (NPP, NVJPEG, NVGRAPH cuBLAS, cuFFT, cuSPARSE, cuSOLVER and cuRAND).

5. Domain Specific

Samples that are specific to domain (Graphics, Finance, Image Processing).

6. Performance

Samples that demonstrate performance optimization.

7. libNVVM

Samples that demonstrate the use of libNVVVM and NVVM IR.

8. Platform Specific

Samples that are specific to certain platforms (Tegra, cuDLA, NvMedia, NvSci, OpenGL ES).

Dependencies

Some CUDA Samples rely on third-party applications and/or libraries, or features provided by the CUDA Toolkit and Driver, to either build or execute. These dependencies are listed below.

If a sample has a third-party dependency that is available on the system, but is not installed, the sample will waive itself at build time.

Each sample's dependencies are listed in its README's Dependencies section.

Third-Party Dependencies

These third-party dependencies are required by some CUDA samples. If available, these dependencies are either installed on your system automatically, or are installable via your system's package manager (Linux) or a third-party website.

FreeImage

FreeImage is an open source imaging library. FreeImage can usually be installed on Linux using your distribution's package manager system. FreeImage can also be downloaded from the FreeImage website.

To set up FreeImage on a Windows system, extract the FreeImage DLL distribution into the folder ./Common/FreeImage/Dist/x64 such that it contains the .h and .lib files. Copy the .dll file to the Release/ Debug/ execution folder or pass the FreeImage folder when cmake configuring with the -DFreeImage_INCLUDE_DIR and -DFreeImage_LIBRARY options.

Message Passing Interface

MPI (Message Passing Interface) is an API for communicating data between distributed processes. A MPI compiler can be installed using your Linux distribution's package manager system. It is also available on some online resources, such as Open MPI. On Windows, to build and run MPI-CUDA applications one can install MS-MPI SDK.

Only 64-Bit

Some samples can only be run on a 64-bit operating system.

DirectX

DirectX is a collection of APIs designed to allow development of multimedia applications on Microsoft platforms. For Microsoft platforms, NVIDIA's CUDA Driver supports DirectX. Several CUDA Samples for Windows demonstrates CUDA-DirectX Interoperability, for building such samples one needs to install Microsoft Visual Studio 2012 or higher which provides Microsoft Windows SDK for Windows 8.

DirectX12

DirectX 12 is a collection of advanced low-level programming APIs which can reduce driver overhead, designed to allow development of multimedia applications on Microsoft platforms starting with Windows 10 OS onwards. For Microsoft platforms, NVIDIA's CUDA Driver supports DirectX. Few CUDA Samples for Windows demonstrates CUDA-DirectX12 Interoperability, for building such samples one needs to install Windows 10 SDK or higher, with VS 2015 or VS 2017.

OpenGL

OpenGL is a graphics library used for 2D and 3D rendering. On systems which support OpenGL, NVIDIA's OpenGL implementation is provided with the CUDA Driver.

OpenGL ES

OpenGL ES is an embedded systems graphics library used for 2D and 3D rendering. On systems which support OpenGL ES, NVIDIA's OpenGL ES implementation is provided with the CUDA Driver.

Freeglut

Freeglut is an open-source software library that serves as a replacement for the original OpenGL Utility Toolkit (GLUT). Its primary purpose is to make it easier for developers to create and manage windows containing OpenGL contexts, as well as handle input from devices like the mouse, keyboard, and joystick, across a wide range of platforms. To set up Freeglut on a Windowson on ARM system, you need to download the source from Freeglut website, build freeglut on your system, and copy the freeglut.lib into the folder ./Common/lib/x64 and copy the freeglut.dll file into the ./bin/win64/${BUILD_TYPE} execution folder.

Vulkan

Vulkan is a low-overhead, cross-platform 3D graphics and compute API. Vulkan targets high-performance realtime 3D graphics applications such as video games and interactive media across all platforms. On systems which support Vulkan, NVIDIA's Vulkan implementation is provided with the CUDA Driver. For building and running Vulkan applications one needs to install the Vulkan SDK.

GLEW

GLEW (OpenGL Extension Wrangler Library) is a cross-platform, open-source C/C++ library designed to simplify the process of using modern OpenGL features and extensions. Its main function is to dynamically load OpenGL function pointers at runtime, allowing developers to access both core OpenGL functions and additional features provided by hardware vendors, known as extensions. To set up GLEW on a Windows on ARM system, you need to download the source from GLEW website, build GLEW on your system, and copy the glew32.lib into the folder ./Common/lib/x64 and the glew32.dll into the ./bin/win64/${BUILD_TYPE} execution folder.

GLFW

GLFW is a lightweight, open-source library designed for managing OpenGL, OpenGL ES, and Vulkan contexts. It simplifies the process of creating and managing windows, handling user input (keyboard, mouse, and joystick), and working with multiple monitors in a cross-platform manner.

To set up GLFW on a Windows system, Download the pre-built binaries from GLFW website and extract the zip file into the folder, pass the GLFW include header folder as -DGLFW_INCLUDE_DIR and lib folder as -DGLFW_LIB_DIR for cmake configuring.

OpenMP

OpenMP is an API for multiprocessing programming. OpenMP can be installed using your Linux distribution's package manager system. It usually comes preinstalled with GCC. It can also be found at the OpenMP website. For compilers such as clang, make sure OpenMP is enabled when building LLVM by including openmp in LLVM_ENABLE_PROJECTS. If you use clang (from an installed prefix or directly from an LLVM build tree) with OpenMP enabled, set CMAKE_CXX_COMPILER and CMAKE_CUDA_HOST_COMPILER to that clang++ and let CMake detect OpenMP; extra OpenMP_* CMake variables are usually not needed. When using clang++ directly from an LLVM build tree, you may need to copy the generated omp.h into the include/ directory under the path reported by clang++ --print-resource-dir before building the samples. When using an installed clang with OpenMP, if you see libomp.so: cannot open shared object file at runtime, add the directory that contains libomp.so to LD_LIBRARY_PATH (or configure it via ld.so.conf.d) so the dynamic linker can locate the OpenMP runtime.

Screen

Screen is a windowing system found on the QNX operating system. Screen is usually found as part of the root filesystem.

X11

X11 is a windowing system commonly found on *-nix style operating systems. X11 can be installed using your Linux distribution's package manager, and comes preinstalled on Mac OS X systems.

EGL

EGL is an interface between Khronos rendering APIs (such as OpenGL, OpenGL ES or OpenVG) and the underlying native platform windowing system.

EGLOutput

EGLOutput is a set of EGL extensions which allow EGL to render directly to the display.

EGLSync

EGLSync is a set of EGL extensions which provides sync objects that are synchronization primitive, representing events whose completion can be tested or waited upon.

NVSCI

NvSci is a set of communication interface libraries out of which CUDA interops with NvSciBuf and NvSciSync. NvSciBuf allows applications to allocate and exchange buffers in memory. NvSciSync allows applications to manage synchronization objects which coordinate when sequences of operations begin and end.

NvMedia

NvMedia provides powerful processing of multimedia data for true hardware acceleration across NVIDIA Tegra devices. Applications leverage the NvMedia Application Programming Interface (API) to process the image and video data.

CUDA Features

These CUDA features are needed by some CUDA samples. They are provided by either the CUDA Toolkit or CUDA Driver. Some features may not be available on your system.

CUFFT Callback Routines

CUFFT Callback Routines are user-supplied kernel routines that CUFFT will call when loading or storing data. These callback routines are only available on Linux x86_64 and ppc64le systems.

CUDA Dynamic Parallellism

CDP (CUDA Dynamic Parallellism) allows kernels to be launched from threads running on the GPU. CDP is only available on GPUs with SM architecture of 3.5 or above.

Multi-block Cooperative Groups

Multi Block Cooperative Groups(MBCG) extends Cooperative Groups and the CUDA programming model to express inter-thread-block synchronization. MBCG is available on GPUs with Pascal and higher architecture.

Multi-Device Cooperative Groups

Multi Device Cooperative Groups extends Cooperative Groups and the CUDA programming model enabling thread blocks executing on multiple GPUs to cooperate and synchronize as they execute. This feature is available on GPUs with Pascal and higher architecture.

CUBLAS

CUBLAS (CUDA Basic Linear Algebra Subroutines) is a GPU-accelerated version of the BLAS library.

CUDA Interprocess Communication

IPC (Interprocess Communication) allows processes to share device pointers.

CUFFT

CUFFT (CUDA Fast Fourier Transform) is a GPU-accelerated FFT library.

CURAND

CURAND (CUDA Random Number Generation) is a GPU-accelerated RNG library.

CUSPARSE

CUSPARSE (CUDA Sparse Matrix) provides linear algebra subroutines used for sparse matrix calculations.

CUSOLVER

CUSOLVER library is a high-level package based on the CUBLAS and CUSPARSE libraries. It combines three separate libraries under a single umbrella, each of which can be used independently or in concert with other toolkit libraries. The intent ofCUSOLVER is to provide useful LAPACK-like features, such as common matrix factorization and triangular solve routines for dense matrices, a sparse least-squares solver and an eigenvalue solver. In addition cuSolver provides a new refactorization library useful for solving sequences of matrices with a shared sparsity pattern.

NPP

NPP (NVIDIA Performance Primitives) provides GPU-accelerated image, video, and signal processing functions.

NVGRAPH

NVGRAPH is a GPU-accelerated graph analytics library.

NVJPEG

NVJPEG library provides high-performance, GPU accelerated JPEG decoding functionality for image formats commonly used in deep learning and hyperscale multimedia applications.

NVRTC

NVRTC (CUDA RunTime Compilation) is a runtime compilation library for CUDA C++.

NVJITLINK

NVJITLINK is a CUDA runtime library that links multiple GPU device code objects at runtime and enables just‑in‑time link‑time optimization (JIT LTO). It can take device code from tools such as NVCC and NVRTC, link and optimize it on the fly, and produce the final GPU binary.For more details, see: https://docs.nvidia.com/cuda/nvjitlink/index.html

Stream Priorities

Stream Priorities allows the creation of streams with specified priorities. Stream Priorities is only available on GPUs with SM architecture of 3.5 or above.

Unified Virtual Memory

UVM (Unified Virtual Memory) enables memory that can be accessed by both the CPU and GPU without explicit copying between the two. UVM is only available on Linux and Windows systems.

16-bit Floating Point

FP16 is a 16-bit floating-point format. One bit is used for the sign, five bits for the exponent, and ten bits for the mantissa.

C++11 CUDA

NVCC support of C++11 features.

CMake

The libNVVM samples are built using CMake 3.10 or later.

Contributors Guide

We welcome your input on issues and suggestions for samples. At this time we are not accepting contributions from the public, check back here as we evolve our contribution model.

We use Google C++ Style Guide for all the sources https://google.github.io/styleguide/cppguide.html

Frequently Asked Questions

Answers to frequently asked questions about CUDA can be found at http://developer.nvidia.com/cuda-faq and in the CUDA Toolkit Release Notes.

References

Attributions

Teapot image is obtained from Wikimedia and is licensed under the Creative Commons Attribution-Share Alike 2.0 Generic license. The image is modified for samples use cases.

PX4/PX4-Autopilot

PX4 Autopilot Software

The autopilot stack the industry builds on.

About

PX4 is an open-source autopilot stack for drones and unmanned vehicles. It supports multirotors, fixed-wing, VTOL, rovers, and many more experimental platforms from racing quads to industrial survey aircraft. It runs on NuttX, Linux, and macOS. Licensed under BSD 3-Clause.

Why PX4

Modular architecture. PX4 is built around uORB, a DDS-compatible publish/subscribe middleware. Modules are fully parallelized and thread safe. You can build custom configurations and trim what you don't need.

Wide hardware support. PX4 runs on a wide range of autopilot boards and supports an extensive set of sensors, telemetry radios, and actuators through the Pixhawk ecosystem.

Developer friendly. First-class support for MAVLink and DDS / ROS 2 integration. Comprehensive SITL simulation, hardware-in-the-loop testing, and log analysis tools. An active developer community on Discord and the weekly dev call.

Vendor neutral governance. PX4 is hosted under the Dronecode Foundation, part of the Linux Foundation. Business-friendly BSD-3 license. No single vendor controls the roadmap.

Supported Vehicles

_Multicopter

_{Fixed Wing}

_VTOL

_Rover

_{…and many more: helicopters, autogyros, airships, submarines, boats, and other experimental platforms. These frames have basic support but are not part of the regular flight-test program. See the full airframe reference.}

Try PX4

Run PX4 in simulation with a single command. No build tools, no dependencies beyond Docker:

docker run --rm -it -p 14550:14550/udp px4io/px4-sitl:latest

Open QGroundControl and fly. See PX4 Simulation Quickstart for more options.

Build from Source

git clone https://github.com/PX4/PX4-Autopilot.git --recursive
cd PX4-Autopilot
make px4_sitl

Note

See the Development Guide for toolchain setup and build options.

Documentation & Resources

Resource	Description
User Guide	Build, configure, and fly with PX4
Developer Guide	Modify the flight stack, add peripherals, port to new hardware
Airframe Reference	Full list of supported frames
Autopilot Hardware	Compatible flight controllers
Release Notes	What's new in each release
Contribution Guide	How to contribute to PX4

Community

Weekly Dev Call — open to all developers (Dronecode calendar)
Discord — Join the Dronecode server
Discussion Forum — PX4 Discuss
Maintainers — see MAINTAINERS.md
Contributor Stats — LFX Insights

Contributing

We welcome contributions of all kinds — bug reports, documentation, new features, and code reviews. Please read the Contribution Guide to get started.

Citation

If you use PX4 in academic work, please cite it. BibTeX:

@software{px4_autopilot,
  author    = {Meier, Lorenz and {The PX4 Contributors}},
  title     = {{PX4 Autopilot}},
  publisher = {Zenodo},
  doi       = {10.5281/zenodo.595432},
  url       = {https://px4.io}
}

The DOI above is a Zenodo concept DOI that always resolves to the latest release. For a version-pinned citation, see the Zenodo record or our CITATION.cff.

Governance

The PX4 Autopilot project is hosted by the Dronecode Foundation, a Linux Foundation Collaborative Project. Dronecode holds all PX4 trademarks and serves as the project's legal guardian, ensuring vendor-neutral stewardship — no single company owns the name or controls the roadmap. The source code is licensed under the BSD 3-Clause license, so you are free to use, modify, and distribute it in your own projects.

monero-project/monero

Monero: the secure, private, untraceable cryptocurrency

Monero

Development resources

Web: getmonero.org
Mail: dev@getmonero.org
GitHub: https://github.com/monero-project/monero
IRC: #monero-dev on Libera
It is HIGHLY recommended that you join the #monero-dev IRC channel if you are developing software that uses Monero. Due to the nature of this open source software project, joining this channel and idling is the best way to stay updated on best practices and new developments in the Monero ecosystem. All you need to do is join the IRC channel and idle to stay updated with the latest in Monero development. If you do not, you risk wasting resources on developing integrations that are not compatible with the Monero network. The Monero core team and community continuously make efforts to communicate updates, developments, and documentation via other platforms – but for the best information, you need to talk to other Monero developers, and they are on IRC. #monero-dev is about Monero development, not getting help about using Monero, or help about development of other software, including yours, unless it also pertains to Monero code itself. For these cases, checkout #monero.

Vulnerability response

Our Vulnerability Response Process encourages responsible disclosure
We are also available via HackerOne

Research

The Monero Research Lab is an open forum where the community coordinates research into Monero cryptography, protocols, fungibility, analysis, and more. We welcome collaboration and contributions from outside researchers! Because not all Lab work and publications are distributed as traditional preprints or articles, they may be easy to miss if you are conducting literature reviews for your own Monero research. You are encouraged to get in touch with the Monero research community if you have questions, wish to collaborate, or would like guidance to help avoid unnecessarily duplicating earlier or known work.

The Monero research community is available on IRC in #monero-research-lab on Libera, which is also accessible via Matrix.

Announcements

You can subscribe to an announcement listserv to get critical announcements from the Monero core team. The announcement list can be very helpful for knowing when software updates are needed.

Translations

The CLI wallet is available in different languages. If you want to help translate it, see our self-hosted localization platform, Weblate, on translate.getmonero.org. Every translation must be uploaded on the platform, pull requests directly editing the code in this repository will be closed. If you need help with Weblate, you can find a guide with screenshots here.

If you need help/support/info about translations, contact the localization workgroup. You can find the complete list of contacts on the repository of the workgroup: monero-translations.

Coverage

Type	Status
Coverity
OSS Fuzz
Coveralls
License

Introduction

Monero is a private, secure, untraceable, decentralised digital currency. You are your bank, you control your funds, and nobody can trace your transfers unless you allow them to do so.

Privacy: Monero uses a cryptographically sound system to allow you to send and receive funds without your transactions being easily revealed on the blockchain (the ledger of transactions that everyone has). This ensures that your purchases, receipts, and all transfers remain private by default.

Security: Using the power of a distributed peer-to-peer consensus network, every transaction on the network is cryptographically secured. Individual wallets have a 25-word mnemonic seed that is only displayed once and can be written down to backup the wallet. Wallet files should be encrypted with a strong passphrase to ensure they are useless if ever stolen.

Untraceability: By taking advantage of ring signatures, a special property of a certain type of cryptography, Monero is able to ensure that transactions are not only untraceable but have an optional measure of ambiguity that ensures that transactions cannot easily be tied back to an individual user or computer.

Decentralization: The utility of Monero depends on its decentralised peer-to-peer consensus network - anyone should be able to run the monero software, validate the integrity of the blockchain, and participate in all aspects of the monero network using consumer-grade commodity hardware. Decentralization of the monero network is maintained by software development that minimizes the costs of running the monero software and inhibits the proliferation of specialized, non-commodity hardware.

About this project

This is the core implementation of Monero. It is open source and completely free to use without restrictions, except for those specified in the license agreement below. There are no restrictions on anyone creating an alternative implementation of Monero that uses the protocol and network in a compatible manner.

As with many development projects, the repository on GitHub is considered to be the "staging" area for the latest changes. Before changes are merged into that branch on the main repository, they are tested by individual developers in their own branches, submitted as a pull request, and then subsequently tested by contributors who focus on testing and code reviews. That having been said, the repository should be carefully considered before using it in a production environment, unless there is a patch in the repository for a particular show-stopping issue you are experiencing. It is generally a better idea to use a tagged release for stability.

Anyone is welcome to contribute to Monero's codebase! If you have a fix or code change, feel free to submit it as a pull request directly to the "master" branch. In cases where the change is relatively small or does not affect other parts of the codebase, it may be merged in immediately by any one of the collaborators. On the other hand, if the change is particularly large or complex, it is expected that it will be discussed at length either well in advance of the pull request being submitted, or even directly on the pull request.

Supporting the project

Monero is a 100% community-sponsored endeavor. If you want to join our efforts, the easiest thing you can do is support the project financially. Both Monero and Bitcoin donations can be made to donate.getmonero.org if using a client that supports the OpenAlias standard. Alternatively, you can send XMR to the Monero donation address via the donate command (type help in the command-line wallet for details).

The Monero donation address is:
888tNkZrPN6JsEgekjMnABU4TBzc2Dt29EPAvkRxbANsAnjyPbb3iQ1YBRk1UXcdRsiKc9dhwMVgN5S9cQUiyoogDavup3H
Viewkey:
f359631075708155cc3d92a32b75a7d02a5dcf27756707b47a2b31b21c389501
Base address for restoring with address and viewkey: 44AFFq5kSiGBoZ4NMDwYtN18obc8AemS33DBLWs3H7otXft3XjrpDtQGv7SqSsaBYBb98uNbr2VBBEt7f2wfn3RVGQBEP3A

The Bitcoin donation address is:
1KTexdemPdxSBcG55heUuTjDRYqbC5ZL8H

Core development funding and/or some supporting services are also graciously provided by sponsors:

There are also several mining pools that kindly donate a portion of their fees, a list of them can be found on our Bitcointalk post.

License

See LICENSE.

Contributing

If you want to help out, see CONTRIBUTING for a set of guidelines.

Scheduled software/network upgrades

Monero uses a scheduled software/network upgrade (hard fork) mechanism to implement new features into the Monero software and network. This means that users of Monero (end users and service providers) should run current versions and upgrade their software when new releases are available. Software upgrades occur when new features are developed and implemented in the codebase. Network upgrades occur in tandem with software upgrades that modify the consensus rules of the Monero network. The required software for network upgrades will be available prior to the scheduled network upgrade date. Please check the repository prior to this date for the proper Monero software version. Below is the historical schedule and the projected schedule for the next upgrade.

Dates are provided in the format YYYY-MM-DD. The "Minimum" is the software version that follows the new consensus rules. The "Recommended" version may include bug fixes and other new features that do not affect the consensus rules.

Software upgrade block height	Date	Fork version	Minimum Monero version	Recommended Monero version	Details
1009827	2016-03-22	v2	v0.9.4	v0.9.4	Allow only >= ringsize 3, blocktime = 120 seconds, fee-free blocksize 60 kb
1141317	2016-09-21	v3	v0.9.4	v0.10.0	Splits coinbase into denominations
1220516	2017-01-05	v4	v0.10.1	v0.10.2.1	Allow normal and RingCT transactions
1288616	2017-04-15	v5	v0.10.3.0	v0.10.3.1	Adjusted minimum blocksize and fee algorithm
1400000	2017-09-16	v6	v0.11.0.0	v0.11.0.0	Allow only RingCT transactions, allow only >= ringsize 5
1546000	2018-04-06	v7	v0.12.0.0	v0.12.3.0	Cryptonight variant 1, ringsize >= 7, sorted inputs
1685555	2018-10-18	v8	v0.13.0.0	v0.13.0.4	max transaction size at half the penalty free block size, bulletproofs enabled, cryptonight variant 2, fixed ringsize 11
1686275	2018-10-19	v9	v0.13.0.0	v0.13.0.4	bulletproofs required
1788000	2019-03-09	v10	v0.14.0.0	v0.14.1.2	New PoW based on Cryptonight-R, new block weight algorithm, slightly more efficient RingCT format
1788720	2019-03-10	v11	v0.14.0.0	v0.14.1.2	forbid old RingCT transaction format
1978433	2019-11-30	v12	v0.15.0.0	v0.16.0.0	New PoW based on RandomX, only allow >= 2 outputs, change to the block median used to calculate penalty, v1 coinbases are forbidden, rct sigs in coinbase forbidden, 10 block lock time for incoming outputs
2210000	2020-10-17	v13	v0.17.0.0	v0.17.3.2	New CLSAG transaction format
2210720	2020-10-18	v14	v0.17.1.1	v0.17.3.2	forbid old MLSAG transaction format
2688888	2022-08-13	v15	v0.18.0.0	v0.18.5.0	ringsize = 16, bulletproofs+, view tags, adjusted dynamic block weight algorithm
2689608	2022-08-14	v16	v0.18.0.0	v0.18.5.0	forbid old v14 transaction format
XXXXXXX	XXX-XX-XX	XXX	vX.XX.X.X	vX.XX.X.X	XXX

X's indicate that these details have not been determined as of commit date.

* indicates estimate as of commit date

Release staging schedule and protocol

Approximately three months prior to a scheduled software upgrade, a branch from master will be created with the new release version tag. Pull requests that address bugs should then be made to both master and the new release branch. Pull requests that require extensive review and testing (generally, optimizations and new features) should not be made to the release branch.

Compiling Monero from source

Dependencies

The following table summarizes the tools and libraries required to build. A few of the libraries are also included in this repository (marked as "Vendored"). By default, the build uses the library installed on the system and ignores the vendored sources. However, if no library is found installed on the system, then the vendored source will be built and used. The vendored sources are also used for statically-linked builds because distribution packages often include only shared library binaries (.so) but not static library archives (.a).

Dep	Min. version	Vendored	Debian/Ubuntu pkg	Arch pkg	Void pkg	Fedora pkg	Optional	Purpose
GCC	7	NO	`build-essential`	`base-devel`	`base-devel`	`gcc`	NO
CMake	3.10	NO	`cmake`	`cmake`	`cmake`	`cmake`	NO
pkg-config	any	NO	`pkg-config`	`base-devel`	`base-devel`	`pkgconf`	NO
Boost	1.66	NO	`libboost-all-dev`	`boost`	`boost-devel`	`boost-devel`	NO	C++ libraries
OpenSSL	basically any	NO	`libssl-dev`	`openssl`	`openssl-devel`	`openssl-devel`	NO	sha256 sum
libzmq	4.2.0	NO	`libzmq3-dev`	`zeromq`	`zeromq-devel`	`zeromq-devel`	NO	ZeroMQ library
libunbound	1.4.16	NO	`libunbound-dev`	`unbound`	`unbound-devel`	`unbound-devel`	NO	DNS resolver
libsodium	?	NO	`libsodium-dev`	`libsodium`	`libsodium-devel`	`libsodium-devel`	NO	cryptography
libunwind	any	NO	`libunwind8-dev`	`libunwind`	`libunwind-devel`	`libunwind-devel`	YES	Stack traces
liblzma	any	NO	`liblzma-dev`	`xz`	`liblzma-devel`	`xz-devel`	YES	For libunwind
libreadline	6.3.0	NO	`libreadline6-dev`	`readline`	`readline-devel`	`readline-devel`	YES	Input editing
expat	1.1	NO	`libexpat1-dev`	`expat`	`expat-devel`	`expat-devel`	YES	XML parsing
GTest	1.5	YES	`libgtest-dev`	`gtest`	`gtest-devel`	`gtest-devel`	YES	Test suite
ccache	any	NO	`ccache`	`ccache`	`ccache`	`ccache`	YES	Compil. cache
Doxygen	any	NO	`doxygen`	`doxygen`	`doxygen`	`doxygen`	YES	Documentation
Graphviz	any	NO	`graphviz`	`graphviz`	`graphviz`	`graphviz`	YES	Documentation
lrelease	?	NO	`qttools5-dev-tools`	`qt5-tools`	`qt5-tools`	`qt5-linguist`	YES	Translations
libhidapi	?	NO	`libhidapi-dev`	`hidapi`	`hidapi-devel`	`hidapi-devel`	YES	Hardware wallet
libusb	?	NO	`libusb-1.0-0-dev`	`libusb`	`libusb-devel`	`libusbx-devel`	YES	Hardware wallet
libprotobuf	?	NO	`libprotobuf-dev`	`protobuf`	`protobuf-devel`	`protobuf-devel`	YES	Hardware wallet
protoc	?	NO	`protobuf-compiler`	`protobuf`	`protobuf`	`protobuf-compiler`	YES	Hardware wallet
libudev	?	NO	`libudev-dev`	`systemd`	`eudev-libudev-devel`	`systemd-devel`	YES	Hardware wallet

Install all dependencies at once on Debian/Ubuntu:

sudo apt update && sudo apt install build-essential cmake pkg-config libssl-dev libzmq3-dev libunbound-dev libsodium-dev libunwind8-dev liblzma-dev libreadline6-dev libexpat1-dev qttools5-dev-tools libhidapi-dev libusb-1.0-0-dev libprotobuf-dev protobuf-compiler libudev-dev libboost-chrono-dev libboost-date-time-dev libboost-filesystem-dev libboost-locale-dev libboost-program-options-dev libboost-regex-dev libboost-serialization-dev libboost-system-dev libboost-thread-dev python3 ccache doxygen graphviz git curl autoconf libtool gperf

Install all dependencies at once on Arch:

sudo pacman -Syu --needed base-devel cmake boost boost-libs openssl zeromq unbound libsodium libunwind xz readline expat python3 ccache doxygen graphviz qt5-tools hidapi libusb protobuf systemd

Install all dependencies at once on Fedora:

sudo dnf install gcc gcc-c++ cmake pkgconf boost-devel openssl-devel zeromq-devel unbound-devel libsodium-devel libunwind-devel xz-devel readline-devel expat-devel ccache doxygen graphviz qt5-linguist hidapi-devel libusbx-devel protobuf-devel protobuf-compiler systemd-devel

Install all dependencies at once on openSUSE:

sudo zypper ref && sudo zypper in cppzmq-devel libboost_chrono-devel libboost_date_time-devel libboost_filesystem-devel libboost_locale-devel libboost_program_options-devel libboost_regex-devel libboost_serialization-devel libboost_system-devel libboost_thread-devel libexpat-devel libsodium-devel libunwind-devel unbound-devel cmake doxygen ccache fdupes gcc-c++ libevent-devel libopenssl-devel pkgconf-pkg-config readline-devel xz-devel libqt5-qttools-devel patterns-devel-C-C++-devel_C_C++

Install all dependencies at once on macOS with the provided Brewfile:

brew update && brew bundle --file=contrib/brew/Brewfile

FreeBSD 12.1 one-liner required to build dependencies:

pkg install git gmake cmake pkgconf boost-libs libzmq4 libsodium unbound

Cloning the repository

Clone recursively to pull-in needed submodule(s):

git clone --recursive https://github.com/monero-project/monero

If you already have a repo cloned, initialize and update:

cd monero && git submodule init && git submodule update

Note: If there are submodule differences between branches, you may need to use git submodule sync && git submodule update after changing branches to build successfully.

Build instructions

Monero uses the CMake build system and a top-level Makefile that invokes cmake commands as needed.

On Linux and macOS

Install the dependencies
Change to the root of the source code directory, change to the most recent release branch, and build:
```
cd monero
git checkout release-v0.18
make
```
Optional: If your machine has several cores and enough memory, enable parallel build by running make -j<number of threads> instead of make. For this to be worthwhile, the machine should have one core and about 2GB of RAM available per thread.

Note: The instructions above will compile the most stable release of the Monero software. If you would like to use and test the most recent software, use git checkout master. The master branch may contain updates that are both unstable and incompatible with release software, though testing is always encouraged.
The resulting executables can be found in build/release/bin
Add PATH="$PATH:$HOME/monero/build/release/bin" to .profile
Run Monero with monerod --detach
Optional: build and run the test suite to verify the binaries:
```
make release-test
```
NOTE: core_tests test may take a few hours to complete.
Optional: to build binaries suitable for debugging:
```
make debug
```
Optional: build documentation in doc/html (omit HAVE_DOT=YES if graphviz is not installed):
```
HAVE_DOT=YES doxygen Doxyfile
```
Optional: use ccache not to rebuild translation units, that haven't really changed. Monero's CMakeLists.txt file automatically handles it
```
sudo apt install ccache
```

On the Raspberry Pi

Tested on a Raspberry Pi 5B with a clean installation of Raspberry Pi OS (64-bit) with Debian 12 from https://www.raspberrypi.com/software/operating-systems/.

apt-get update && apt-get upgrade to install the latest software
Install the dependencies for Monero from the 'Debian' column in the table above.

Optional: increase the system swap size:

sudo /etc/init.d/dphys-swapfile stop  
sudo nano /etc/dphys-swapfile  
CONF_SWAPSIZE=2048
sudo /etc/init.d/dphys-swapfile start

If using an external hard disk without an external power supply, ensure it gets enough power to avoid hardware issues when syncing, by adding the line "max_usb_current=1" to /boot/config.txt

Clone Monero and checkout the most recent release version:

git clone --recursive https://github.com/monero-project/monero.git
cd monero
git checkout v0.18.4.1

Build:
```
USE_SINGLE_BUILDDIR=1 make release
```
Wait a few hours
The resulting executables can be found in build/release/bin
Add export PATH="$PATH:$HOME/monero/build/release/bin" to $HOME/.profile
Run source $HOME/.profile
Run Monero with monerod --detach
You may wish to reduce the size of the swap file after the build has finished, and delete the boost directory from your home directory

On Windows:

Binaries for Windows can be built on Windows using the MinGW toolchain within MSYS2 environment. The MSYS2 environment emulates a POSIX system. The toolchain runs within the environment and cross-compiles binaries that can run outside of the environment as a regular Windows application.

Preparing the build environment

Download and install the MSYS2 installer. Installing MSYS2 requires 64-bit Windows 10 or newer.
Open the MSYS shell via the MSYS2 MSYS shortcut
Update packages using pacman:
```
pacman -Syu
```

Install dependencies:

pacman -S mingw-w64-x86_64-toolchain make mingw-w64-x86_64-cmake mingw-w64-x86_64-boost mingw-w64-x86_64-openssl mingw-w64-x86_64-zeromq mingw-w64-x86_64-libsodium mingw-w64-x86_64-hidapi mingw-w64-x86_64-unbound

Open the MingW shell via MSYS2 MINGW64 shortcut.

Cloning

To git clone, run:

git clone --recursive https://github.com/monero-project/monero.git

Building

Change to the cloned directory, run:
```
cd monero
```
If you would like a specific version/tag, do a git checkout for that version. eg. 'v0.18.4.1'. If you don't care about the version and just want binaries from master, skip this step:
```
git checkout v0.18.4.1
```
To build Monero, run:
```
make release-static -j $(nproc)
```
The resulting executables can be found in build/release/bin
Optional: to build Windows binaries suitable for debugging, run:
```
make debug -j $(nproc)
```
The resulting executables can be found in build/debug/bin

On FreeBSD:

The project can be built from scratch by following instructions for Linux above(but use gmake instead of make). If you are running Monero in a jail, you need to add sysvsem="new" to your jail configuration, otherwise lmdb will throw the error message: Failed to open lmdb environment: Function not implemented.

Monero is also available as a port or package as monero-cli.

On OpenBSD:

You will need to add a few packages to your system. pkg_add cmake gmake zeromq libiconv boost libunbound.

The doxygen and graphviz packages are optional and require the xbase set. Running the test suite also requires py3-requests package.

Build monero: gmake

Note: you may encounter the following error when compiling the latest version of Monero as a normal user:

LLVM ERROR: out of memory
c++: error: unable to execute command: Abort trap (core dumped)

Then you need to increase the data ulimit size to 2GB and try again: ulimit -d 2000000

On NetBSD:

Check that the dependencies are present: pkg_info -c libexecinfo boost-headers boost-libs protobuf readline libusb1 zeromq git-base pkgconf gmake cmake | more, and install any that are reported missing, using pkg_add or from your pkgsrc tree. Readline is optional but worth having.

Third-party dependencies are usually under /usr/pkg/, but if you have a custom setup, adjust the "/usr/pkg" (below) accordingly.

Clone the monero repository recursively and checkout the most recent release as described above. Then build monero: gmake BOOST_ROOT=/usr/pkg LDFLAGS="-Wl,-R/usr/pkg/lib" release. The resulting executables can be found in build/NetBSD/[Release version]/Release/bin/.

On Solaris:

The default Solaris linker can't be used, you have to install GNU ld, then run cmake manually with the path to your copy of GNU ld:

mkdir -p build/release
cd build/release
cmake -DCMAKE_LINKER=/path/to/ld -D CMAKE_BUILD_TYPE=Release ../..
cd ../..

Then you can run make as usual.

Cross Compiling

You can also cross-compile static binaries on Linux for Windows and macOS with the depends system.

make depends target=x86_64-linux-gnu for 64-bit linux binaries.

make depends target=x86_64-w64-mingw32 for 64-bit windows binaries.

Requires: g++-mingw-w64-x86-64

You also need to run:

update-alternatives --set x86_64-w64-mingw32-g++ $(which x86_64-w64-mingw32-g++-posix) && \
update-alternatives --set x86_64-w64-mingw32-gcc $(which x86_64-w64-mingw32-gcc-posix)

make depends target=x86_64-apple-darwin for Intel macOS binaries.
- Requires: clang-18 lld-18
make depends target=arm64-apple-darwin for Apple Silicon macOS binaries.
- Requires: clang-18 lld-18
- You also need to run:
```
export PATH="/usr/lib/llvm-18/bin/:$PATH"
```
make depends target=i686-linux-gnu for 32-bit linux binaries.
- Requires: g++-multilib bc
make depends target=i686-w64-mingw32 for 32-bit windows binaries.
- Requires: python3 g++-mingw-w64-i686
make depends target=arm-linux-gnueabihf for armv7 binaries.
- Requires: g++-arm-linux-gnueabihf
make depends target=aarch64-linux-gnu for armv8 binaries.
- Requires: g++-aarch64-linux-gnu
make depends target=riscv64-linux-gnu for RISC V 64 bit binaries.
- Requires: g++-riscv64-linux-gnu
make depends target=x86_64-unknown-freebsd for freebsd binaries.
- Requires: clang-8
make depends target=arm-linux-android for 32bit android binaries
make depends target=aarch64-linux-android for 64bit android binaries

The required packages are the names for each toolchain on apt. Depending on your distro, they may have different names. The depends system has been tested on Ubuntu 18.04 and 20.04.

Using depends might also be easier to compile Monero on Windows than using MSYS. Activate Windows Subsystem for Linux (WSL) with a distro (for example Ubuntu), install the apt build-essentials and follow the depends steps as depicted above.

The produced binaries still link libc dynamically. If the binary is compiled on a current distribution, it might not run on an older distribution with an older installation of libc.

Trezor hardware wallet support

If you have an issue with building Monero with Trezor support, you can disable it by setting USE_DEVICE_TREZOR=OFF, e.g.,

USE_DEVICE_TREZOR=OFF make release

For more information, please check out Trezor src/device_trezor/README.md.

Guix builds

See contrib/guix/README.md.

Installing Monero from a package

DISCLAIMER: These packages are not part of this repository or maintained by this project's contributors, and as such, do not go through the same review process to ensure their trustworthiness and security.

Packages are available for

Debian 12 (Bookworm) or later
```
sudo apt install monero
```
More info and versions in the Debian package tracker.
Arch Linux:
```
sudo pacman -S monero
```
NixOS:
```
nix-shell -p monero-cli
```
Guix:
```
guix package -i monero
```

Gentoo Monero overlay

emerge --noreplace eselect-repository
eselect repository enable monero
emaint sync -r monero
echo '*/*::monero ~amd64' >> /etc/portage/package.accept_keywords
emerge net-p2p/monero

Alpine Linux:
```
apk add monero
```
macOS (homebrew)
```
brew install monero
```

Docker

# Build using all available cores
docker build -t monero .

# or build using a specific number of cores (reduce RAM requirement)
docker build --build-arg NPROC=1 -t monero .

# either run in foreground
docker run -it -v /monero/chain:/home/monero/.bitmonero -v /monero/wallet:/wallet -p 18080:18080 monero

# or in background
docker run -it -d -v /monero/chain:/home/monero/.bitmonero -v /monero/wallet:/wallet -p 18080:18080 monero

The build needs 3 GB space.
Wait one hour or more

Packaging for your favorite distribution would be a welcome contribution!

Running monerod

The build places the binary in bin/ sub-directory within the build directory from which cmake was invoked (repository root by default). To run in the foreground:

./bin/monerod

To list all available options, run ./bin/monerod --help. Options can be specified either on the command line or in a configuration file passed by the --config-file argument. To specify an option in the configuration file, add a line with the syntax argumentname=value, where argumentname is the name of the argument without the leading dashes, for example, log-level=1.

To run in background:

./bin/monerod --log-file monerod.log --detach

To run as a systemd service, copy monerod.service to /etc/systemd/system/ and monerod.conf to /etc/. The example service assumes that the user monero exists and its home is the data directory specified in the example config.

If you're on Mac, you may need to add the --max-concurrency 1 option to monero-wallet-cli, and possibly monerod, if you get crashes refreshing.

Internationalization

See README.i18n.md.

Using Tor

There is a new, still experimental, integration with Tor. The feature allows connecting over IPv4 and Tor simultaneously - IPv4 is used for relaying blocks and relaying transactions received by peers whereas Tor is used solely for relaying transactions received over local RPC. This provides privacy and better protection against surrounding node (sybil) attacks.

While Monero isn't made to integrate with Tor, it can be used wrapped with torsocks, by setting the following configuration parameters and environment variables:

--p2p-bind-ip 127.0.0.1 on the command line or p2p-bind-ip=127.0.0.1 in monerod.conf to disable listening for connections on external interfaces.
If you use the wallet with a Tor daemon via the loopback IP (eg, 127.0.0.1:9050), then use --untrusted-daemon unless it is your own hidden service.

Example command line to start monerod through Tor:

monerod --proxy 127.0.0.1:9050 --p2p-bind-ip 127.0.0.1

A helper script is in contrib/tor/monero-over-tor.sh. It assumes Tor is installed already, and runs Tor and Monero with the right configuration.

Using Tor on Tails

TAILS ships with a very restrictive set of firewall rules. Therefore, you need to add a rule to allow this connection too, in addition to telling torsocks to allow inbound connections. Full example:

sudo iptables -I OUTPUT 2 -p tcp -d 127.0.0.1 -m tcp --dport 18081 -j ACCEPT
DNS_PUBLIC=tcp torsocks ./monerod --p2p-bind-ip 127.0.0.1 --rpc-bind-ip 127.0.0.1 \
    --data-dir /home/amnesia/Persistent/your/directory/to/the/blockchain

Pruning

As of April 2022, the full Monero blockchain file is about 130 GB. One can store a pruned blockchain, which is about 45 GB. A pruned blockchain can only serve part of the historical chain data to other peers, but is otherwise identical in functionality to the full blockchain. To use a pruned blockchain, it is best to start the initial sync with --prune-blockchain. However, it is also possible to prune an existing blockchain using the monero-blockchain-prune tool or using the --prune-blockchain monerod option with an existing chain. If an existing chain exists, pruning will temporarily require disk space to store both the full and pruned blockchains.

For more detailed information see the 'Pruning' entry in the Moneropedia

Debugging

This section contains general instructions for debugging failed installs or problems encountered with Monero. First, ensure you are running the latest version built from the GitHub repo.

Obtaining stack traces and core dumps on Unix systems

We generally use the tool gdb (GNU debugger) to provide stack trace functionality, and ulimit to provide core dumps in builds which crash or segfault.

To use gdb in order to obtain a stack trace for a build that has stalled:

Run the build.

Once it stalls, enter the following command:

gdb /path/to/monerod `pidof monerod`

Type thread apply all bt within gdb in order to obtain the stack trace

If however the core dumps or segfaults:

Enter ulimit -c unlimited on the command line to enable unlimited filesizes for core dumps

Enter echo core | sudo tee /proc/sys/kernel/core_pattern to stop cores from being hijacked by other tools

Run the build.

When it terminates with an output along the lines of "Segmentation fault (core dumped)", there should be a core dump file in the same directory as monerod. It may be named just core, or core.xxxx with numbers appended.

You can now analyse this core dump with gdb as follows:

gdb /path/to/monerod /path/to/dumpfile`

Print the stack trace with bt

If a program crashed and cores are managed by systemd, the following can also get a stack trace for that crash:

coredumpctl -1 gdb

To run Monero within gdb:

Type gdb /path/to/monerod

Pass command-line options with --args followed by the relevant arguments

Type run to run monerod

Analysing memory corruption

There are two tools available:

ASAN

Configure Monero with the -D SANITIZE=ON cmake flag, eg:

cd build/debug && cmake -D SANITIZE=ON -D CMAKE_BUILD_TYPE=Debug ../..

You can then run the monero tools normally. Performance will typically halve.

valgrind

Install valgrind and run as valgrind /path/to/monerod. It will be very slow.

LMDB

Instructions for debugging suspected blockchain corruption as per @HYC

There is an mdb_stat command in the LMDB source that can print statistics about the database but it's not routinely built. This can be built with the following command:

cd ~/monero/external/db_drivers/liblmdb && make

The output of mdb_stat -ea <path to blockchain dir> will indicate inconsistencies in the blocks, block_heights and block_info table.

The output of mdb_dump -s blocks <path to blockchain dir> and mdb_dump -s block_info <path to blockchain dir> is useful for indicating whether blocks and block_info contain the same keys.

These records are dumped as hex data, where the first line is the key and the second line is the data.

Known Issues

Protocols

Socket-based

Because of the nature of the socket-based protocols that drive monero, certain protocol weaknesses are somewhat unavoidable at this time. While these weaknesses can theoretically be fully mitigated, the effort required (the means) may not justify the ends. As such, please consider taking the following precautions if you are a monero node operator:

Run monerod on a "secured" machine. If operational security is not your forte, at a very minimum, have a dedicated a computer running monerod and do not browse the web, use email clients, or use any other potentially harmful apps on your monerod machine. Do not click links or load URL/MUA content on the same machine. Doing so may potentially exploit weaknesses in commands which accept "localhost" and "127.0.0.1".
If you plan on hosting a public "remote" node, start monerod with --restricted-rpc. This is a must.

Blockchain-based

Certain blockchain "features" can be considered "bugs" if misused correctly. Consequently, please consider the following:

When receiving monero, be aware that it may be locked for an arbitrary time if the sender elected to, preventing you from spending that monero until the lock time expires. You may want to hold off acting upon such a transaction until the unlock time lapses. To get a sense of that time, you can consider the remaining blocktime until unlock as seen in the show_transfers command.

Alexays/Waybar

Highly customizable Wayland bar for Sway and Wlroots based compositors. ✌️ 🎉

Waybar

Highly customizable Wayland bar for Sway and Wlroots based compositors.
Available in all major distributions
Waybar examples

Current features

Sway (Workspaces, Binding mode, Focused window name)
River (Mapping mode, Tags, Focused window name)
Hyprland (Window Icons, Workspaces, Focused window name)
Niri (Workspaces, Focused window name, Language)
DWL (Tags, Focused window name) requires dwl ipc patch
Tray #21
Local time
Battery
UPower
Power profiles daemon
Network
Bluetooth
Pulseaudio
Privacy Info
Wireplumber
Disk
Memory
Cpu load average
Temperature
MPD
Custom scripts
Custom image
Multiple output configuration
And many more customizations

Configuration and Styling

See the wiki for more details.

Installation

Waybar is available from a number of Linux distributions:

An Ubuntu PPA with more recent versions is available here.

Building from source

$ git clone https://github.com/Alexays/Waybar
$ cd Waybar
$ meson setup build
$ ninja -C build
$ ./build/waybar
# If you want to install it
$ ninja -C build install
$ waybar

Dependencies

gtkmm3
jsoncpp
libsigc++
fmt
wayland
chrono-date
spdlog
libgtk-3-dev [gtk-layer-shell]
gobject-introspection [gtk-layer-shell]
libgirepository1.0-dev [gtk-layer-shell]
libpulse [Pulseaudio module]
libnl [Network module]
libappindicator-gtk3 [Tray module]
libdbusmenu-gtk3 [Tray module]
libmpdclient [MPD module]
libsndio [sndio module]
libevdev [KeyboardState module]
xkbregistry
upower [UPower battery module]

Build dependencies

cmake
meson
scdoc
wayland-protocols

On Ubuntu, you can install all the relevant dependencies using this command (tested with 19.10 and 20.04):

sudo apt install \
  clang-tidy \
  gobject-introspection \
  libdbusmenu-gtk3-dev \
  libevdev-dev \
  libfmt-dev \
  libgirepository1.0-dev \
  libgtk-3-dev \
  libgtkmm-3.0-dev \
  libinput-dev \
  libjsoncpp-dev \
  libmpdclient-dev \
  libnl-3-dev \
  libnl-genl-3-dev \
  libpulse-dev \
  libsigc++-2.0-dev \
  libspdlog-dev \
  libwayland-dev \
  scdoc \
  upower \
  libxkbregistry-dev

On Arch, you can use this command:

pacman -S --asdeps \
  gtkmm3 \
  jsoncpp \
  libsigc++ \
  fmt \
  wayland \
  chrono-date \
  spdlog \
  gtk3 \
  gobject-introspection \
  libgirepository \
  libpulse \
  libnl \
  libappindicator-gtk3 \
  libdbusmenu-gtk3 \
  libmpdclient \
  sndio \
  libevdev \
  libxkbcommon \
  upower \
  meson \
  cmake \
  scdoc \
  wayland-protocols \
  glib2-devel

Contributions welcome!
Have fun 😃
The style guidelines are Google's

Caution

Distributions of Waybar are only released on the official GitHub page.
Waybar does not have an official website. Do not trust any sites that claim to be official.

License

Waybar is licensed under the MIT license. See LICENSE for more information.

envoyproxy/envoy

Cloud-native high-performance edge/middle/service proxy

Envoy is hosted by the Cloud Native Computing Foundation (CNCF). If you are a company that wants to help shape the evolution of technologies that are container-packaged, dynamically-scheduled and microservices-oriented, consider joining the CNCF. For details about who's involved and how Envoy plays a role, read the CNCF announcement.

Documentation

Official documentation
FAQ
Example documentation
Blog about the threading model
Blog about hot restart
Blog about stats architecture
Blog about universal data plane API
Blog on Lyft's Envoy dashboards

data-plane-api: v2 API definitions as a standalone repository. This is a read-only mirror of api.
envoy-perf: Performance testing framework.
envoy-filter-example: Example of how to add new filters and link to the main repository.

Contact

envoy-announce: Low frequency mailing list where we will email announcements only.
envoy-security-announce: Low frequency mailing list where we will email security related announcements only.
envoy-users: General user discussion.
envoy-dev: Envoy developer discussion (APIs, feature design, etc.).
envoy-maintainers: Use this list to reach all core Envoy maintainers.
Twitter: Follow along on Twitter!
Slack: Slack, to get invited go here.
- NOTE: Response to user questions is best effort on Slack. For a "guaranteed" response please email envoy-users@ per the guidance in the following linked thread.

Please see this email thread for information on email list usage.

Contributing

Contributing to Envoy is fun and modern C++ is a lot less scary than you might think if you don't have prior experience. To get started:

Contributing guide
Beginner issues
Build/test quick start using docker
Developer guide
Consider installing the Envoy development support toolchain, which helps automate parts of the development process, particularly those involving code review.
Please make sure that you let us know if you are working on an issue so we don't duplicate work!

Community Meeting

The Envoy team has a scheduled meeting time twice per month on Tuesday at 9am PT. The public Google calendar is here. The meeting will only be held if there are agenda items listed in the meeting minutes. Any member of the community should be able to propose agenda items by adding to the minutes. The maintainers will either confirm the additions to the agenda, or will cancel the meeting within 24 hours of the scheduled date if there is no confirmed agenda.

Security

Security Audit

There has been several third party engagements focused on Envoy security:

In 2018 Cure53 performed a security audit, full report.
In 2021 Ada Logics performed an audit on our fuzzing infrastructure with recommendations for improvements, full report.

Reporting security vulnerabilities

If you've found a vulnerability or a potential vulnerability in Envoy, please open a GitHub Security Advisory. This is the preferred reporting channel, as the reports can be triaged directly on GitHub.

Alternatively, you may email envoy-security@googlegroups.com.

For further details please see our complete security release process.

OSS fuzzing

ppc64le builds

Builds for the ppc64le architecture or using aws-lc are not covered by the envoy security policy. The ppc64le architecture is currently best-effort and not maintained by the Envoy maintainers.

Other builds

Releases

For further details please see our release process.

NVIDIA/nccl

Optimized primitives for collective multi-GPU communication

NCCL

Optimized primitives for inter-GPU communication.

Introduction

NCCL (pronounced "Nickel") is a stand-alone library of standard communication routines for GPUs, implementing all-reduce, all-gather, reduce, broadcast, reduce-scatter, as well as any send/receive based communication pattern. It has been optimized to achieve high bandwidth on platforms using PCIe, NVLink, NVswitch, as well as networking using InfiniBand Verbs or TCP/IP sockets. NCCL supports an arbitrary number of GPUs installed in a single node or across multiple nodes, and can be used in either single- or multi-process (e.g., MPI) applications.

For more information on NCCL usage, please refer to the NCCL documentation.

Build

Note: the official and tested builds of NCCL can be downloaded from: https://developer.nvidia.com/nccl. You can skip the following build steps if you choose to use the official builds.

To build the library :

$ cd nccl
$ make -j src.build

If CUDA is not installed in the default /usr/local/cuda path, you can define the CUDA path with :

$ make src.build CUDA_HOME=<path to cuda install>

NCCL will be compiled and installed in build/ unless BUILDDIR is set.

By default, NCCL is compiled for all supported architectures. To accelerate the compilation and reduce the binary size, consider redefining NVCC_GENCODE (defined in makefiles/common.mk) to only include the architecture of the target platform :

$ make -j src.build NVCC_GENCODE="-gencode=arch=compute_90,code=sm_90"

Install

To install NCCL on the system, create a package then install it as root.

Debian/Ubuntu :

$ # Install tools to create debian packages
$ sudo apt install build-essential devscripts debhelper fakeroot
$ # Build NCCL deb package
$ make pkg.debian.build
$ ls build/pkg/deb/

RedHat/CentOS :

$ # Install tools to create rpm packages
$ sudo yum install rpm-build rpmdevtools
$ # Build NCCL rpm package
$ make pkg.redhat.build
$ ls build/pkg/rpm/

OS-agnostic tarball :

$ make pkg.txz.build
$ ls build/pkg/txz/

Tests

Tests for NCCL are maintained separately at https://github.com/nvidia/nccl-tests.

$ git clone https://github.com/NVIDIA/nccl-tests.git
$ cd nccl-tests
$ make
$ ./build/all_reduce_perf -b 8 -e 256M -f 2 -g <ngpus>

Copyright

azerothcore/azerothcore-wotlk

Complete Open Source and Modular solution for MMO

AzerothCore

Build Status

Introduction

AzerothCore is an open-source game server application and framework designed for hosting massively multiplayer online role-playing games (MMORPGs). It is based on the popular MMORPG World of Warcraft (WoW) and seeks to recreate the gameplay experience of the original game from patch 3.3.5a.

The original code is based on MaNGOS, TrinityCore, and SunwellCore and has since then had extensive development to improve stability, in-game mechanics, and modularity to the game. AC has also grown into a community-driven project with a significant number of contributors and developers. It is written in C++ and provides a solid foundation for creating private servers that mimic the mechanics and behavior of the official WoW servers.

Philosophy

Our main goal is to create a playable game server, offering a fully working in-game experience.

Here are the main points we focus on:

Stability
- We make sure all changes pass the CIs before being merged into the master branch.
Blizzlike content
- We strive to make all in-game content to be blizzlike. Therefore we have a high standard for fixes being made.
Customization
- It is easy to customize your experience using modules.
Community driven
- AzerothCore has an active community of developers, contributors, and users who collaborate, share knowledge, and provide support through forums, Discord channels, and other communication platforms.

Modules

AzerothCore is designed to be highly modular, allowing developers to extend and customize the game to suit their preferences or create unique gameplay experiences. This flexibility enables the addition of custom features, content, and modifications.

We have a lot of modules already made by the community, many of which can be found in the Module Catalogue.

Installation

Detailed installation instructions are available here.

Contributing

AzerothCore can also serve as a learning resource for aspiring developers who want to understand how WoW servers work, how MMORPGs are structured, how game server emulators are created, or to improve their C++ and SQL knowledge.

If you want to contribute to the project, you will find a lot of resources that will guide you in our wiki.

We also recommend you read our Contributor Covenant Code of Conduct.

Feel free to join our Discord server.

Click on the "⭐ Star" button to help us gain more visibility on Github!

Authors & Contributors

The project was born in 2016 based on SunwellCore. Unfortunately, SunwellCore was published without any git history, so on git there are no credits for all the contributors before 2016.

You can check the authors file for more details.

License

The AzerothCore source code is released under the GNU GPL v2

It's important to note that AzerothCore is not an official Blizzard Entertainment product, and it is not affiliated with or endorsed by World of Warcraft or Blizzard Entertainment. AzerothCore does not in any case sponsor nor support illegal public servers. If you use this project to run an illegal public server and not for testing and learning it is your own personal choice.

Special thanks

JetBrains is providing free open-source licenses to the AzerothCore developers.