GitHub C Daily Trending

lvgl/lvgl

Embedded graphics library to create beautiful UIs for any MCU, MPU and display type.

English | 中文 | Português do Brasil | 日本語 | עברית

Light and Versatile Graphics Library

Overview
Features
Platform Support
LVGL Pro Editor
Commercial Services
Integrating LVGL
Examples
Contributing

📒 Overview

LVGL is a free and open-source UI library that enables you to create graphical user interfaces for any MCUs and MPUs from any vendor on any platform.

Requirements: LVGL has no external dependencies, which makes it easy to compile for any modern target, from small MCUs to multi-core Linux-based MPUs with 3D support. For a simple UI, you need only ~100kB RAM, ~200–300kB flash, and a buffer size of 1/10 of the screen for rendering.

To get started, pick a ready-to-use VSCode, Eclipse, or any other project and try out LVGL on your PC. The LVGL UI code is fully platform-independent, so you can use the same UI code on embedded targets too.

LVGL Pro is a complete toolkit to help you build, test, share, and ship UIs faster. It comes with an XML Editor where you can quickly create and test reusable components, export C code, or load the XMLs at runtime. Learn more here.

💡 Features

Free and Portable

A fully portable C (C++ compatible) library with no external dependencies.
Can be compiled for any MCU or MPU, with any (RT)OS. Make, CMake, and simple globbing are all supported.
Supports monochrome, ePaper, OLED, or TFT displays, or even monitors. Displays
Distributed under the MIT license, so you can easily use it in commercial projects too.
Needs only 32kB RAM and 128kB Flash, a frame buffer, and at least a 1/10 screen-sized buffer for rendering.
OS, external memory, and GPU are supported but not required.

Widgets, Styles, Layouts, and More

30+ built-in Widgets: Button, Label, Slider, Chart, Keyboard, Meter, Arc, Table, and many more.
Flexible Style system with ~100 style properties to customize any part of the widgets in any state.
Flexbox and Grid-like layout engines to automatically size and position the widgets responsively.
Text is rendered with UTF-8 encoding, supporting CJK, Thai, Hindi, Arabic, and Persian writing systems.
Data bindings to easily connect the UI with the application.
Rendering engine supports animations, anti-aliasing, opacity, smooth scrolling, shadows, image transformation, etc.
Powerful 3D rendering engine to show glTF models with OpenGL.
Supports Mouse, Touchpad, Keypad, Keyboard, External buttons, Encoder Input devices.
Multiple display support.

📦️ Platform Support

LVGL has no external dependencies, so it can be easily compiled for any devices and it's also available in many package managers and RTOSes:

🚀 LVGL Pro Editor

LVGL Pro is a complete toolkit to build, test, share, and ship embedded UIs efficiently.

It consists of four tightly related tools:

XML Editor: The heart of LVGL Pro. A desktop app to build components and screens in XML, manage data bindings, translations, animations, tests, and more. Learn more about the XML Format and the Editor.
Online Viewer: Run the Editor in your browser, open GitHub projects, and share easily without setting up a developer environment. Visit https://viewer.lvgl.io.
CLI Tool: Generate C code and run tests in CI/CD. See the details here.
Figma Plugin: Sync and extract styles directly from Figma. See how it works here.

Together, these tools let developers build UIs efficiently, test them reliably, and collaborate with team members and customers.

Learn more at https://pro.lvgl.io

🤝 Commercial Services

LVGL LLC provides several types of commercial services to help you with UI development. With 15+ years of experience in the user interface and graphics industry, we can help bring your UI to the next level.

Graphics design: Our in-house graphic designers are experts in creating beautiful modern designs that fit your product and the capabilities of your hardware.
UI implementation: We can implement your UI based on the design you or we have created. You can be sure that we will make the most of your hardware and LVGL. If a feature or widget is missing from LVGL, don't worry, we will implement it for you.
Consulting and Support: We also offer consulting to help you avoid costly and time-consuming mistakes during UI development.
Board certification: For companies offering development boards or production-ready kits, we provide board certification to show how the board can run LVGL.

Check out our Demos as references. For more information, take a look at the Services page.

🧑‍💻 Integrating LVGL

Integrating LVGL is very simple. Just drop it into any project and compile it as you would compile other files. To configure LVGL, copy lv_conf_template.h as lv_conf.h, enable the first #if 0, and adjust the configs as needed. (The default config is usually fine.) If available, LVGL can also be used with Kconfig.

Once in the project, you can initialize LVGL and create display and input devices as follows:

#include "lvgl/lvgl.h" /*Define LV_LVGL_H_INCLUDE_SIMPLE to include as "lvgl.h"*/

#define TFT_HOR_RES 320
#define TFT_VER_RES 240

static uint32_t my_tick_cb(void)
{
    return my_get_millisec();
}

static void my_flush_cb(lv_display_t * disp, const lv_area_t * area, uint8_t * px_map)
{
    /*Write px_map to the area->x1, area->x2, area->y1, area->y2 area of the
     *frame buffer or external display controller. */

    /* signal LVGL that we're done */
    lv_display_flush_ready(disp);
}

static void my_touch_read_cb(lv_indev_t * indev, lv_indev_data_t * data)
{
   if(my_touch_is_pressed()) {
       data->point.x = touchpad_x;
       data->point.y = touchpad_y;
       data->state = LV_INDEV_STATE_PRESSED;
   } else {
       data->state = LV_INDEV_STATE_RELEASED;
   }
}

void main(void)
{
    my_hardware_init();

    /*Initialize LVGL*/
    lv_init();

    /*Set millisecond-based tick source for LVGL so that it can track time.*/
    lv_tick_set_cb(my_tick_cb);

    /*Create a display where screens and widgets can be added*/
    lv_display_t * display = lv_display_create(TFT_HOR_RES, TFT_VER_RES);

    /*Add rendering buffers to the screen.
     *Here adding a smaller partial buffer assuming 16-bit (RGB565 color format)*/
    static uint8_t buf[TFT_HOR_RES * TFT_VER_RES / 10 * 2]; /* x2 because of 16-bit color depth */
    lv_display_set_buffers(display, buf, NULL, sizeof(buf), LV_DISPLAY_RENDER_MODE_PARTIAL);

    /*Add a callback that can flush the content from `buf` when it has been rendered*/
    lv_display_set_flush_cb(display, my_flush_cb);

    /*Create an input device for touch handling*/
    lv_indev_t * indev = lv_indev_create();
    lv_indev_set_type(indev, LV_INDEV_TYPE_POINTER);
    lv_indev_set_read_cb(indev, my_touch_read_cb);

    /*The drivers are in place; now we can create the UI*/
    lv_obj_t * label = lv_label_create(lv_screen_active());
    lv_label_set_text(label, "Hello world");
    lv_obj_center(label);

    /*Execute the LVGL-related tasks in a loop*/
    while(1) {
        lv_timer_handler();
        my_sleep_ms(5);         /*Wait a little to let the system breathe*/
    }
}

🤖 Examples

You can check out more than 100 examples at https://docs.lvgl.io/master/examples.html

The Online Viewer also contains tutorials to easily learn XML: https://viewer.lvgl.io/

Hello World Button with an Event

C code

static void button_clicked_cb(lv_event_t * e)
{
  printf("Clicked\n");
}

[...]

lv_obj_t * button = lv_button_create(lv_screen_active());
lv_obj_center(button);
lv_obj_add_event_cb(button, button_clicked_cb, LV_EVENT_CLICKED, NULL);

lv_obj_t * label = lv_label_create(button);
lv_label_set_text(label, "Hello from LVGL!");

In XML with LVGL Pro

<screen>
	<view>
		<lv_button align="center">
			<event_cb callback="button_clicked_cb" />
			<lv_label text="Hello from LVGL!" />
		</lv_button>
	</view>
</screen>

Styled Slider with Data-binding

C code

static void my_observer_cb(lv_observer_t * observer, lv_subject_t * subject)
{
	printf("Slider value: %d\n", lv_subject_get_int(subject));
}

[...]

static lv_subject_t subject_value;
lv_subject_init_int(&subject_value, 35);
lv_subject_add_observer(&subject_value, my_observer_cb, NULL);

lv_style_t style_base;
lv_style_init(&style_base);
lv_style_set_bg_color(&style_base, lv_color_hex(0xff8800));
lv_style_set_bg_opa(&style_base, 255);
lv_style_set_radius(&style_base, 4);

lv_obj_t * slider = lv_slider_create(lv_screen_active());
lv_obj_center(slider);
lv_obj_set_size(slider, lv_pct(80), 16);
lv_obj_add_style(slider, &style_base, LV_PART_INDICATOR);
lv_obj_add_style(slider, &style_base, LV_PART_KNOB);
lv_obj_add_style(slider, &style_base, 0);
lv_obj_set_style_bg_opa(slider, LV_OPA_50, 0);
lv_obj_set_style_border_width(slider, 3, LV_PART_KNOB);
lv_obj_set_style_border_color(slider, lv_color_hex3(0xfff), LV_PART_KNOB);
lv_slider_bind_value(slider, &subject_value);

lv_obj_t * label = lv_label_create(lv_screen_active());
lv_obj_align(label, LV_ALIGN_CENTER, 0, -30);
lv_label_bind_text(label, &subject_value, "Temperature: %d °C");

In XML with LVGL Pro

<screen>
	<styles>
		<style name="style_base" bg_opa="100%" bg_color="0xff8800" radius="4" />
		<style name="style_border" border_color="0xfff" border_width="3" />
	</styles>

	<view>
		<lv_label bind_text="value" bind_text-fmt="Temperature: %d °C" align="center" y="-30" />
		<lv_slider align="center" bind_value="value" style_bg_opa="30%">
			<style name="style_base" />
			<style name="style_base" selector="knob" />
			<style name="style_base" selector="indicator" />
			<style name="style_border" selector="knob" />
		</lv_slider>
	</view>
</screen>

Checkboxes in a Layout

C code

/*Create a new screen and load it*/
lv_obj_t * scr = lv_obj_create(NULL);
lv_screen_load(scr);

/*Set a column layout*/
lv_obj_set_flex_flow(scr, LV_FLEX_FLOW_COLUMN);
lv_obj_set_flex_align(scr, LV_FLEX_ALIGN_SPACE_EVENLY, /*Vertical alignment*/
  					   LV_FLEX_ALIGN_START,	       /*Horizontal alignment in the track*/
  					   LV_FLEX_ALIGN_CENTER);      /*Horizontal alignment of the track*/

/*Create 5 checkboxes*/
const char * texts[5] = {"Input 1", "Input 2", "Input 3", "Output 1", "Output 2"};
for(int i = 0; i < 5; i++) {
  lv_obj_t * cb = lv_checkbox_create(scr);
  lv_checkbox_set_text(cb, texts[i]);
}

/*Change some states*/
lv_obj_add_state(lv_obj_get_child(scr, 1), LV_STATE_CHECKED);
lv_obj_add_state(lv_obj_get_child(scr, 3), LV_STATE_DISABLED);

In XML with LVGL Pro

<screen>
	<view
		flex_flow="column"
		style_flex_main_place="space_evenly"
		style_flex_cross_place="start"
		style_flex_track_place="center"
	>
		<lv_checkbox text="Input 1"/>
		<lv_checkbox text="Input 2"/>
		<lv_checkbox text="Input 3" checked="true"/>
		<lv_checkbox text="Output 1"/>
		<lv_checkbox text="Output 2" disabled="true"/>
   </view>
</screen>

🌟 Contributing

LVGL is an open project, and contributions are very welcome. There are many ways to contribute, from simply speaking about your project, writing examples, improving the documentation, fixing bugs, or even hosting your own project under the LVGL organization.

For a detailed description of contribution opportunities, visit the Contributing section of the documentation.

More than 600 people have already left their fingerprint on LVGL. Be one of them! See you here! 🙂

... and many more.

pbatard/rufus

The Reliable USB Formatting Utility

Rufus: The Reliable USB Formatting Utility

Rufus is a utility that helps format and create bootable USB flash drives.

Features

Format USB, flash card and virtual drives to FAT/FAT32/NTFS/UDF/exFAT/ReFS/ext2/ext3
Create DOS bootable USB drives using FreeDOS or MS-DOS
Create BIOS or UEFI bootable drives, including UEFI bootable NTFS
Create bootable drives from bootable ISOs (Windows, Linux, etc.)
Create bootable drives from bootable disk images, including compressed ones
Create Windows 11 installation drives for PCs that don't have TPM or Secure Boot
Create Windows To Go drives
Create VHD/DD, VHDX and FFU images of an existing drive
Create persistent Linux partitions
Compute MD5, SHA-1, SHA-256 and SHA-512 checksums of the selected image
Perform runtime validation of UEFI bootable media
Improve Windows installation experience by automatically setting up OOBE parameters (local account, privacy options, etc.)
Perform bad blocks checks, including detection of "fake" flash drives
Download official Microsoft Windows 8, Windows 10 or Windows 11 retail ISOs
Download UEFI Shell ISOs
Modern and familiar UI, with 38 languages natively supported
Small footprint. No installation required.
Portable. Secure Boot compatible.
100% Free Software (GPL v3)

Compilation

Use either Visual Studio 2022 or MinGW and then invoke the .sln or configure/make respectively.

Visual Studio

Rufus is an OSI compliant Open Source project. You are entitled to download and use the freely available Visual Studio Community Edition to build, run or develop for Rufus. As per the Visual Studio Community Edition license, this applies regardless of whether you are an individual or a corporate user.

Additional information

Rufus provides extensive information about what it is doing, either through its easily accessible log, or through the Windows debug facility.

Enhancements/Bugs

Please use the GitHub issue tracker for reporting problems or suggesting new features.

espressif/esp-idf

Espressif IoT Development Framework. Official development framework for Espressif SoCs.

Espressif IoT Development Framework

中文版

ESP-IDF is the development framework for Espressif SoCs supported on Windows, Linux and macOS.

ESP-IDF Release Support Schedule

Please read the support policy and the documentation for more information about ESP-IDF versions.
Please see the End-of-Life Advisories for information about ESP-IDF releases with discontinued support.

ESP-IDF Release and SoC Compatibility

See Compatibility Between ESP-IDF Releases and Revisions of Espressif SoCs for the details of the compatibility between ESP-IDF and chip revisions.

Espressif SoCs released before 2016 (ESP8266 and ESP8285) are supported by RTOS SDK instead.

Developing With ESP-IDF

Setting Up ESP-IDF

See https://idf.espressif.com/ for links to detailed instructions on how to set up the ESP-IDF depending on chip you use.

Note: Each SoC series and each ESP-IDF release has its own documentation. Please see Section Versions on how to find documentation and how to checkout specific release of ESP-IDF.

Non-GitHub forks

ESP-IDF uses relative locations as its submodules URLs (.gitmodules). So they link to GitHub. If ESP-IDF is forked to a Git repository which is not on GitHub, you will need to run the script tools/set-submodules-to-github.sh after git clone.

The script sets absolute URLs for all submodules, allowing git submodule update --init --recursive to complete. If cloning ESP-IDF from GitHub, this step is not needed.

Finding a Project

As well as the esp-idf-template project mentioned in Getting Started, ESP-IDF comes with some example projects in the examples directory.

Once you've found the project you want to work with, change to its directory and you can configure and build it.

To start your own project based on an example, copy the example project directory outside of the ESP-IDF directory.

Quick Reference

See the Getting Started guide links above for a detailed setup guide. This is a quick reference for common commands when working with ESP-IDF projects:

Setup Build Environment

(See the Getting Started guide listed above for a full list of required steps with more details.)

Install host build dependencies mentioned in the Getting Started guide.
Run the install script to set up the build environment. The options include install.bat or install.ps1 for Windows, and install.sh or install.fish for Unix shells.
Run the export script on Windows (export.bat) or source it on Unix (source export.sh) in every shell environment before using ESP-IDF.

Configuring the Project

idf.py set-target <chip_name> sets the target of the project to <chip_name>. Run idf.py set-target without any arguments to see a list of supported targets.
idf.py menuconfig opens a text-based configuration menu where you can configure the project.

Compiling the Project

idf.py build

... will compile app, bootloader and generate a partition table based on the config.

Flashing the Project

When the build finishes, it will print a command line to use esptool to flash the chip. However you can also do this automatically by running:

idf.py -p PORT flash

Replace PORT with the name of your serial port (like COM3 on Windows, /dev/ttyUSB0 on Linux, or /dev/cu.usbserial-X on MacOS. If the -p option is left out, idf.py flash will try to flash the first available serial port.

This will flash the entire project (app, bootloader and partition table) to a new chip. The settings for serial port flashing can be configured with idf.py menuconfig.

You don't need to run idf.py build before running idf.py flash, idf.py flash will automatically rebuild anything which needs it.

Viewing Serial Output

The idf.py monitor target uses the esp-idf-monitor tool to display serial output from Espressif SoCs. esp-idf-monitor also has a range of features to decode crash output and interact with the device. Check the documentation page for details.

Exit the monitor by typing Ctrl-].

To build, flash and monitor output in one pass, you can run:

idf.py flash monitor

Compiling & Flashing Only the App

After the initial flash, you may just want to build and flash just your app, not the bootloader and partition table:

idf.py app - build just the app.
idf.py app-flash - flash just the app.

idf.py app-flash will automatically rebuild the app if any source files have changed.

(In normal development there's no downside to reflashing the bootloader and partition table each time, if they haven't changed.)

Erasing Flash

The idf.py flash target does not erase the entire flash contents. However it is sometimes useful to set the device back to a totally erased state, particularly when making partition table changes or OTA app updates. To erase the entire flash, run idf.py erase-flash.

This can be combined with other targets, ie idf.py -p PORT erase-flash flash will erase everything and then re-flash the new app, bootloader and partition table.

Resources

Documentation for the latest version: https://docs.espressif.com/projects/esp-idf/. This documentation is built from the docs directory of this repository.
Beginner's Guide to Key Concepts and Resources of ESP-IDF
The esp32.com forum is a place to ask questions and find community resources.
Check the Issues section on github if you find a bug or have a feature request. Please check existing Issues before opening a new one.
If you're interested in contributing to ESP-IDF, please check the Contributions Guide.

lightpanda-io/browser

Lightpanda: the headless browser designed for AI and automation

Lightpanda Browser

The headless browser built from scratch for AI agents and automation.
Not a Chromium fork. Not a WebKit patch. A new browser, written in Zig.

Benchmarks

Requesting 933 real web pages over the network on a AWS EC2 m5.large instance. See benchmark details.

Metric	Lightpanda	Headless Chrome	Difference
Memory (peak, 100 pages)	123MB	2GB	~16 less
Execution time (100 pages)	5s	46s	~9x faster

Quick start

Install

Install from the nightly builds

You can download the last binary from the nightly builds for Linux x86_64 and MacOS aarch64.

For Linux

curl -L -o lightpanda https://github.com/lightpanda-io/browser/releases/download/nightly/lightpanda-x86_64-linux && \
chmod a+x ./lightpanda

Verify the binary before running anything:

./lightpanda version

Linux aarch64 is also available

Note: The Linux release binaries are linked against glibc. On musl-based distros (Alpine, etc.) the binary fails with cannot execute: required file not found because the glibc dynamic linker is missing. Use a glibc-based base image (e.g., FROM debian:bookworm-slim or FROM ubuntu:24.04) or build from sources.

For MacOS

curl -L -o lightpanda https://github.com/lightpanda-io/browser/releases/download/nightly/lightpanda-aarch64-macos && \
chmod a+x ./lightpanda

MacOS x86_64 is also available

For Windows + WSL2

Lightpanda has no native Windows binary. Install it inside WSL following the Linux steps above.

WSL not installed? Run wsl --install from an administrator shell, restart, then open wsl. See Microsoft's WSL install guide for details.

Your automation client (Puppeteer, Playwright, etc.) can run either inside WSL or on the Windows host. WSL forwards localhost:9222 automatically.

Install from Docker

Lightpanda provides official Docker images for both Linux amd64 and arm64 architectures. The following command fetches the Docker image and starts a new container exposing Lightpanda's CDP server on port 9222.

docker run -d --name lightpanda -p 127.0.0.1:9222:9222 lightpanda/browser:nightly

Dump a URL

./lightpanda fetch --obey-robots --dump html --log-format pretty  --log-level info https://demo-browser.lightpanda.io/campfire-commerce/

You can use --dump markdown to convert directly into markdown. --wait-until, --wait-ms, --wait-selector and --wait-script are available to adjust waiting time before dump.

Start a CDP server

./lightpanda serve --obey-robots --log-format pretty  --log-level info --host 127.0.0.1 --port 9222

Once the CDP server started, you can run a Puppeteer script by configuring the browserWSEndpoint.

Example Puppeteer script

import puppeteer from 'puppeteer-core';

// use browserWSEndpoint to pass the Lightpanda's CDP server address.
const browser = await puppeteer.connect({
  browserWSEndpoint: "ws://127.0.0.1:9222",
});

// The rest of your script remains the same.
const context = await browser.createBrowserContext();
const frame = await context.newPage();

// Dump all the links from the frame.
await frame.goto('https://demo-browser.lightpanda.io/amiibo/', {waitUntil: "networkidle0"});

const links = await frame.evaluate(() => {
  return Array.from(document.querySelectorAll('a')).map(row => {
    return row.getAttribute('href');
  });
});

console.log(links);

await frame.close();
await context.close();
await browser.disconnect();

Native MCP and skill

The MCP server communicates via MCP JSON-RPC 2.0 over stdio.

Add to your MCP configuration:

{
  "mcpServers": {
    "lightpanda": {
      "command": "/path/to/lightpanda",
      "args": ["mcp"]
    }
  }
}

Read full documentation

A skill is available in lightpanda-io/agent-skill.

Telemetry

By default, Lightpanda collects and sends usage telemetry. This can be disabled by setting an environment variable LIGHTPANDA_DISABLE_TELEMETRY=true. You can read Lightpanda's privacy policy at: https://lightpanda.io/privacy-policy.

Status

Lightpanda is in Beta and currently a work in progress. Stability and coverage are improving and many websites now work. You may still encounter errors or crashes. Please open an issue with specifics if so.

Here are the key features we have implemented:

NOTE: There are hundreds of Web APIs. Developing a browser (even just for headless mode) is a huge task. Coverage will increase over time.

Build from sources

Prerequisites

Lightpanda is written with Zig 0.15.2. You have to install it with the right version in order to build the project.

Lightpanda also depends on v8, Libcurl and html5ever.

To be able to build the v8 engine, you have to install some libs:

For Debian/Ubuntu based Linux:

sudo apt install xz-utils ca-certificates \
    pkg-config libglib2.0-dev \
    clang make curl git

You also need to install Rust.

For systems with Nix, you can use the devShell:

nix develop

For MacOS, you need cmake and Rust.

brew install cmake

Build and run

You an build the entire browser with make build or make build-dev for debug env.

But you can directly use the zig command: zig build run.

Embed v8 snapshot

Lighpanda uses v8 snapshot. By default, it is created on startup but you can embed it by using the following commands:

Generate the snapshot.

zig build snapshot_creator -- src/snapshot.bin

Build using the snapshot binary.

zig build -Dsnapshot_path=../../snapshot.bin

See #1279 for more details.

Test

Unit Tests

You can test Lightpanda by running make test.

End to end tests

To run end to end tests, you need to clone the demo repository into ../demo dir.

You have to install the demo's node requirements

You also need to install Go > v1.24.

make end2end

Web Platform Tests

Lightpanda is tested against the standardized Web Platform Tests.

We use a fork including a custom testharnessreport.js.

For reference, you can easily execute a WPT test case with your browser via wpt.live.

Configure WPT HTTP server

To run the test, you must clone the repository, configure the custom hosts and generate the MANIFEST.json file.

Clone the repository with the fork branch.

git clone -b fork --depth=1 git@github.com:lightpanda-io/wpt.git

Enter into the wpt/ dir.

Install custom domains in your /etc/hosts

./wpt make-hosts-file | sudo tee -a /etc/hosts

Generate MANIFEST.json

./wpt manifest

Use the WPT's setup guide for details.

Run WPT test suite

An external Go runner is provided by github.com/lightpanda-io/demo/ repository, located into wptrunner/ dir. You need to clone the project first.

First start the WPT's HTTP server from your wpt/ clone dir.

./wpt serve

Run a Lightpanda browser

zig build run -- --insecure-disable-tls-host-verification

Then you can start the wptrunner from the Demo's clone dir:

cd wptrunner && go run .

Or one specific test:

cd wptrunner && go run . Node-childNodes.html

wptrunner command accepts --summary and --json options modifying output. Also --concurrency define the concurrency limit.

⚠️ Running the whole test suite will take a long time. In this case, it's useful to build in releaseFast mode to make tests faster.

zig build -Doptimize=ReleaseFast run

Contributing

See CONTRIBUTING.md for guidelines. You must sign our CLA during the pull request process.

Discord

Why Lightpanda?

Javascript execution is mandatory for the modern web

Simple HTTP requests used to be enough for web automation. That's no longer the case. Javascript now drives most of the web:

Ajax, Single Page Apps, infinite loading, instant search
JS frameworks: React, Vue, Angular, and others

Chrome is not the right tool

Running a full desktop browser on a server works, but it does not scale well. Chrome at hundreds or thousands of instances is expensive:

Heavy on RAM and CPU
Hard to package, deploy, and maintain at scale
Many features are not necessary in headless made

Lightpanda is built for performance

Supporting Javascript with real performance meant building from scratch rather than forking Chromium:

Not based on Chromium, Blink, or WebKit
Written in Zig, a low-level language with explicit memory control
No graphical rendering engine

qmk/qmk_firmware

Open-source keyboard firmware for Atmel AVR and Arm USB families

Quantum Mechanical Keyboard Firmware

This is a keyboard firmware based on the tmk_keyboard firmware with some useful features for Atmel AVR and ARM controllers, and more specifically, the OLKB product line, the ErgoDox EZ keyboard, and the Clueboard product line.

Documentation

See the official documentation on docs.qmk.fm

The docs are powered by VitePress. They are also viewable offline; see Previewing the Documentation for more details.

You can request changes by making a fork and opening a pull request.

Supported Keyboards

The project also includes community support for lots of other keyboards.

Maintainers

QMK is developed and maintained by Jack Humbert of OLKB with contributions from the community, and of course, Hasu. The OLKB product firmwares are maintained by Jack Humbert, the Ergodox EZ by ZSA Technology Labs, the Clueboard by Zach White, and the Atreus by Phil Hagelberg.

Official Website

qmk.fm is the official website of QMK, where you can find links to this page, the documentation, and the keyboards supported by QMK.

timescale/timescaledb

A time-series database for high-performance real-time analytics packaged as a Postgres extension

TimescaleDB is a PostgreSQL extension for high-performance real-time analytics on time-series and event data

Quick Start with TimescaleDB

Get started with TimescaleDB in under 10 minutes. This guide will help you run TimescaleDB locally, create your first hypertable with columnstore enabled, write data to the columnstore, and see instant analytical query performance.

What You'll Learn

How to run TimescaleDB with a one-line install or Docker command
How to create a hypertable with columnstore enabled
How to insert data directly to the columnstore
How to execute analytical queries

Prerequisites

Docker installed on your machine
8GB RAM recommended
psql client (included with PostgreSQL) or any PostgreSQL client like pgAdmin

Step 1: Start TimescaleDB

You have two options to start TimescaleDB:

Option 1: One-line install (Recommended)

The easiest way to get started:

Important: This script is intended for local development and testing only. Do not use it for production deployments. For production-ready installation options, see the TimescaleDB installation guide.

Linux/Mac:

curl -sL https://tsdb.co/start-local | sh

This command:

Downloads and starts TimescaleDB (if not already downloaded)
Exposes PostgreSQL on port 6543 (a non-standard port to avoid conflicts with other PostgreSQL instances on port 5432)
Automatically tunes settings for your environment using timescaledb-tune
Sets up a persistent data volume

Option 2: Manual Docker command also used for Windows

Alternatively, you can run TimescaleDB directly with Docker:

docker run -d --name timescaledb \
    -p 6543:5432 \
    -e POSTGRES_PASSWORD=password \
    timescale/timescaledb-ha:pg18

Note: We use port 6543 (mapped to container port 5432) to avoid conflicts if you have other PostgreSQL instances running on the standard port 5432.

Wait about 1-2 minutes for TimescaleDB to download & initialize.

Step 2: Connect to TimescaleDB

Connect using psql:

psql -h localhost -p 6543 -U postgres
# When prompted, enter password: password

You should see the PostgreSQL prompt. Verify TimescaleDB is installed:

SELECT extname, extversion FROM pg_extension WHERE extname = 'timescaledb';

Expected output:

   extname   | extversion
-------------+------------
 timescaledb | 2.x.x

Prefer a GUI? If you'd rather use a graphical tool instead of the command line, you can download pgAdmin and connect to TimescaleDB using the same connection details (host: localhost, port: 6543, user: postgres, password: password).

Step 3: Create Your First Hypertable

Let's create a hypertable for IoT sensor data with columnstore enabled:

-- Create a hypertable with automatic columnstore
CREATE TABLE sensor_data (
    time TIMESTAMPTZ NOT NULL,
    sensor_id TEXT NOT NULL,
    temperature DOUBLE PRECISION,
    humidity DOUBLE PRECISION,
    pressure DOUBLE PRECISION
) WITH (
    tsdb.hypertable
);
-- create index
CREATE INDEX idx_sensor_id_time ON sensor_data(sensor_id, time DESC);

tsdb.hypertable - Converts this into a TimescaleDB hypertable

See more:

Step 4: Insert Sample Data

Let's add some sample sensor readings:

-- Enable timing to see time to execute queries
\timing on

-- Insert sample data for multiple sensors
-- SET timescaledb.enable_direct_compress_insert = on to insert data directly to the columnstore (columnnar format for performance)
SET timescaledb.enable_direct_compress_insert = on;
INSERT INTO sensor_data (time, sensor_id, temperature, humidity, pressure)
SELECT
    time,
    'sensor_' || ((random() * 9)::int + 1),
    20 + (random() * 15),
    40 + (random() * 30),
    1000 + (random() * 50)
FROM generate_series(
    NOW() - INTERVAL '90 days',
    NOW(),
    INTERVAL '1 seconds'
) AS time;

-- Once data is inserted into the columnstore we optimize the order and structure 
-- this compacts and orders the data in the chunks for optimal query performance and compression
DO $$
DECLARE ch TEXT;
BEGIN
    FOR ch IN SELECT show_chunks('sensor_data') LOOP
        CALL convert_to_columnstore(ch, recompress := true);
    END LOOP;
END $$;

This generates ~7,776,001 readings across 10 sensors over the past 90 days.

Verify the data was inserted:

SELECT COUNT(*) FROM sensor_data;

Step 5: Run Your First Analytical Queries

Now let's run some analytical queries that showcase TimescaleDB's performance:

-- Enable query timing to see performance
\timing on

-- Query 1: Average readings per sensor over the last 7 days
SELECT
    sensor_id,
    COUNT(*) as readings,
    ROUND(AVG(temperature)::numeric, 2) as avg_temp,
    ROUND(AVG(humidity)::numeric, 2) as avg_humidity,
    ROUND(AVG(pressure)::numeric, 2) as avg_pressure
FROM sensor_data
WHERE time > NOW() - INTERVAL '7 days'
GROUP BY sensor_id
ORDER BY sensor_id;

-- Query 2: Hourly averages using time_bucket 
-- Time buckets enable you to aggregate data in hypertables by time interval and calculate summary values.
SELECT
    time_bucket('1 hour', time) AS hour,
    sensor_id,
    ROUND(AVG(temperature)::numeric, 2) as avg_temp,
    ROUND(AVG(humidity)::numeric, 2) as avg_humidity
FROM sensor_data
WHERE time > NOW() - INTERVAL '24 hours'
GROUP BY hour, sensor_id
ORDER BY hour DESC, sensor_id
LIMIT 20;

-- Query 3: Daily statistics across all sensors
SELECT
    time_bucket('1 day', time) AS day,
    COUNT(*) as total_readings,
    ROUND(AVG(temperature)::numeric, 2) as avg_temp,
    ROUND(MIN(temperature)::numeric, 2) as min_temp,
    ROUND(MAX(temperature)::numeric, 2) as max_temp
FROM sensor_data
GROUP BY day
ORDER BY day DESC
LIMIT 10;

-- Query 4: Latest reading for each sensor
-- Highlights the value of Skipscan executing in under 100ms without skipscan it takes over 5sec
SELECT DISTINCT ON (sensor_id)
    sensor_id,
    time,
    ROUND(temperature::numeric, 2) as temperature,
    ROUND(humidity::numeric, 2) as humidity,
    ROUND(pressure::numeric, 2) as pressure
FROM sensor_data
ORDER BY sensor_id, time DESC;

Notice how fast these analytical queries run, even with aggregations across millions of rows. This is the power of TimescaleDB's columnstore.

What's Happening Behind the Scenes?

TimescaleDB automatically:

Partitions your data into time-based chunks for efficient querying
Write directly to columnstore using columnar storage (90%+ compression typical) and faster vectorized queries
Optimizes queries by only scanning relevant time ranges and columns
Enables time_bucket() - a powerful function for time-series aggregation

See more:

Next Steps

Now that you've got the basics, explore more:

Create Continuous Aggregates

Continuous aggregates make real-time analytics run faster on very large datasets. They continuously and incrementally refresh a query in the background, so that when you run such query, only the data that has changed needs to be computed, not the entire dataset. This is what makes them different from regular PostgreSQL materialized views, which cannot be incrementally materialized and have to be rebuilt from scratch every time you want to refresh them.

Let's create a continuous aggregate for hourly sensor statistics:

Step 1: Create the Continuous Aggregate

CREATE MATERIALIZED VIEW sensor_data_hourly
WITH (timescaledb.continuous) AS
SELECT
    time_bucket('1 hour', time) AS hour,
    sensor_id,
    AVG(temperature) AS avg_temp,
    AVG(humidity) AS avg_humidity,
    AVG(pressure) AS avg_pressure,
    MIN(temperature) AS min_temp,
    MAX(temperature) AS max_temp,
    COUNT(*) AS reading_count
FROM sensor_data
GROUP BY hour, sensor_id;

This creates a materialized view that pre-aggregates your sensor data into hourly buckets. The view is automatically populated with existing data.

Step 2: Add a Refresh Policy

To keep the continuous aggregate up-to-date as new data arrives, add a refresh policy:

SELECT add_continuous_aggregate_policy(
    'sensor_data_hourly',
    start_offset => INTERVAL '3 hours',
    end_offset => INTERVAL '1 hour',
    schedule_interval => INTERVAL '1 hour'
);

This policy:

Refreshes the continuous aggregate every hour
Processes data from 3 hours ago up to 1 hour ago (leaving the most recent hour for real-time queries)
Only processes new or changed data incrementally

Step 3: Query the Continuous Aggregate

Now you can query the pre-aggregated data for much faster results:

-- Get hourly averages for the last 24 hours
SELECT
    hour,
    sensor_id,
    ROUND(avg_temp::numeric, 2) AS avg_temp,
    ROUND(avg_humidity::numeric, 2) AS avg_humidity,
    reading_count
FROM sensor_data_hourly
WHERE hour > NOW() - INTERVAL '24 hours'
ORDER BY hour DESC, sensor_id
LIMIT 50;

Benefits of Continuous Aggregates

Faster queries: Pre-aggregated data means queries run in milliseconds instead of seconds
Incremental refresh: Only new/changed data is processed, not the entire dataset
Automatic updates: The refresh policy keeps your aggregates current without manual intervention
Real-time option: You can enable real-time aggregation to combine materialized and raw data

Try It Yourself

Compare the performance difference:

-- Query the raw hypertable (slower on large datasets)
\timing on
SELECT
    time_bucket('1 hour', time) AS hour,
    AVG(temperature) AS avg_temp
FROM sensor_data
WHERE time > NOW() - INTERVAL '60 days'
GROUP BY hour
ORDER BY hour DESC
LIMIT 24;

-- Query the continuous aggregate (much faster)
SELECT
    hour,
    avg_temp
FROM sensor_data_hourly
WHERE hour > NOW() - INTERVAL '60 days'
ORDER BY hour DESC
LIMIT 24;

Notice how the continuous aggregate query is significantly faster, especially as your dataset grows!

See more:

Examples

Learn TimescaleDB with complete, standalone examples using real-world datasets. Each example includes sample data and analytical queries.

NYC Taxi Data - Transportation and location-based analytics
Financial Market Data - Trading and market data analysis
Application Events - Event logging with UUIDv7

Or try some of our workshops

AI Workshop: EV Charging Station Analysis - Integrate PostgreSQL with AI capabilities for managing and analyzing EV charging station data
Time-Series Workshop: Financial Data Analysis - Work with cryptocurrency tick data, create candlestick charts

Want TimescaleDB hosted and managed for you? Try Tiger Cloud

Tiger Cloud is the modern PostgreSQL data platform for all your applications. It enhances PostgreSQL to handle time series, events, real-time analytics, and vector search—all in a single database alongside transactional workloads. You get one system that handles live data ingestion, late and out-of-order updates, and low latency queries, with the performance, reliability, and scalability your app needs. Ideal for IoT, crypto, finance, SaaS, and a myriad other domains, Tiger Cloud allows you to build data-heavy, mission-critical apps while retaining the familiarity and reliability of PostgreSQL. See our whitepaper for a deep dive into Tiger Cloud's architecture and how it meets the needs of even the most demanding applications.

A Tiger Cloud service is a single optimized 100% PostgreSQL database instance that you use as is, or extend with capabilities specific to your business needs. The available capabilities are:

Time-series and analytics: PostgreSQL with TimescaleDB. The PostgreSQL you know and love, supercharged with functionality for storing and querying time-series data at scale for real-time analytics and other use cases. Get faster time-based queries with hypertables, continuous aggregates, and columnar storage. Save on storage with native compression, data retention policies, and bottomless data tiering to Amazon S3.
AI and vector: PostgreSQL with vector extensions. Use PostgreSQL as a vector database with purpose built extensions for building AI applications from start to scale. Get fast and accurate similarity search with the pgvector and pgvectorscale extensions. Create vector embeddings and perform LLM reasoning on your data with the pgai extension.
PostgreSQL: the trusted industry-standard RDBMS. Ideal for applications requiring strong data consistency, complex relationships, and advanced querying capabilities. Get ACID compliance, extensive SQL support, JSON handling, and extensibility through custom functions, data types, and extensions. All services include all the cloud tooling you'd expect for production use: automatic backups, high availability, read replicas, data forking, connection pooling, tiered storage, usage-based storage, and much more.

Check build status

Linux/macOS	Linux i386	Windows	Coverity	Code Coverage	OpenSSF

Get involved

We welcome contributions to TimescaleDB! See Contributing and Code style guide for details.

Learn about Tiger Data

Tiger Data is the fastest PostgreSQL for transactional, analytical and agentic workloads. To learn more about the company and its products, visit tigerdata.com.

Troubleshooting

Docker container won't start

# Check if container is running
docker ps -a

# View container logs (use the appropriate container name)
# For one-line install:
docker logs timescaledb-ha-pg18-quickstart
# For manual Docker command:
docker logs timescaledb

# Stop and remove existing container
# For one-line install:
docker stop timescaledb-ha-pg18-quickstart && docker rm timescaledb-ha-pg18-quickstart
# For manual Docker command:
docker stop timescaledb && docker rm timescaledb

# Start fresh
# Option 1: Use the one-line install
curl -sL https://tsdb.co/start-local | sh
# Option 2: Use manual Docker command
docker run -d --name timescaledb -p 6543:5432 -e POSTGRES_PASSWORD=password timescale/timescaledb-ha:pg18

Can't connect with psql

Verify Docker container is running: docker ps
Check port 6543 isn't already in use: lsof -i :6543
Try using explicit host: psql -h 127.0.0.1 -p 6543 -U postgres

TimescaleDB extension not found

The timescale/timescaledb-ha:pg18 image has TimescaleDB pre-installed and pre-loaded. If you see errors, ensure you're using the correct image.

Clean Up

When you're done experimenting:

If you used the one-line install:

# Stop the container
docker stop timescaledb-ha-pg18-quickstart

# Remove the container
docker rm timescaledb-ha-pg18-quickstart

# Remove the persistent data volume
docker volume rm timescaledb_data

# (Optional) Remove the Docker image
docker rmi timescale/timescaledb-ha:pg18

If you used the manual Docker command:

# Stop the container
docker stop timescaledb

# Remove the container
docker rm timescaledb

# (Optional) Remove the Docker image
docker rmi timescale/timescaledb-ha:pg18

Note: If you created a named volume with the manual Docker command, you can remove it with docker volume rm <volume_name>.

vedderb/bldc

The VESC motor control firmware

VESC firmware

An open source motor controller firmware.

This is the source code for the VESC DC/BLDC/FOC controller. Read more at https://vesc-project.com/

Supported boards

All of them!

Check the supported boards by typing make

[Firmware]
     fw   - Build firmware for default target
                            supported boards are: 100_250 100_250_no_limits 100_500...

There are also many other options that can be changed in conf_general.h.

Prerequisites

On Ubuntu (Linux)/macOS

Tools: git, wget, and make
Additional Linux requirements: libgl-dev and libxcb-xinerama0
Helpful Ubuntu commands:

sudo apt install git build-essential libgl-dev libxcb-xinerama0 wget git-gui

Helpful macOS tools:

brew install stlink
brew install openocd

On Windows

Chocolately: https://chocolatey.org/install
Git: https://git-scm.com/download/win. Make sure to click any boxes to add Git to your Environment (aka PATH)

Install Dev environment and build

On Ubuntu (Linux)/MacOS

Open up a terminal

git clone http://github.com/vedderb/bldc.git
cd bldc
Continue with On all platforms

On Windows

Open up a Windows Powershell terminal (Resist the urge to run Powershell as administrator, that will break things)
Type choco install make
git clone http://github.com/vedderb/bldc
cd bldc
Continue with On all platforms

On all platforms

git checkout origin/master
make arm_sdk_install
make <-- Pick out the name of your target device from the supported boards list. For instance, I have a Trampa VESC 100/250, so my target is 100_250
make 100_250 <-- This will build the VESC 100/250 firmware and place it into the bldc/builds/100_250/ directory

Other tools

Linux Optional - Add udev rules to use the stlink v2 programmer without being root

wget vedder.se/Temp/49-stlinkv2.rules
sudo mv 49-stlinkv2.rules /etc/udev/rules.d/
sudo udevadm trigger

IDE

Prerequisites

On macOS/Linux

python3, and pip

On Windows

Python 3: https://www.python.org/downloads/. Make sure to click the box to add Python3 to your Environment.

All platforms

pip install aqtinstall
make qt_install
Open Qt Creator IDE installed in tools/Qt/Tools/QtCreator/bin/qtcreator
With Qt Creator, open the vesc firmware Qt Creator project, named vesc.pro. You will find it in Project/Qt Creator/vesc.pro
The IDE is configured by default to build 100_250 firmware, this can be changed in the bottom of the left panel, there you will find all hardware variants supported by VESC

Upload to VESC

Method 1 - Flash it using an STLink SWD debugger

Build and flash the bootloader first
Then _flash to the target of your choice. So for instance, for the VESC 100/250:

make 100_250_flash

Method 2 - Upload Firmware via VESC tool through USB

Clone and build the firmware in .bin format as in the above Build instructions

In VESC tool

Connect to the VESC
Navigate to the Firmware tab on the left side menu
Click on Custom file tab
Click on the folder icon to select the built firmware in .bin format (e.g. build/100_250/100_250.bin)

[ Reminder : It is normal to see VESC disconnects during the firmware upload process ]

[ Warning : DO NOT DISCONNECT POWER/USB to VESC during the upload process, or you will risk bricking your VESC ]

[ Warning : ONLY DISCONNECT your VESC 10s after the upload loading bar completed and "FW Upload DONE" ]

Press the upload firmware button (downward arrow) on the bottom right to start upload the selected firmware.
Wait for 10s after the loading bar completed (Warning: unplug sooner will risk bricking your VESC)
The VESC will disconnect itself after new firmware is uploaded.

In case you bricked your VESC

you will need to upload a new working firmware to the VESC.
However, to upload a firmware to a bricked VESC, you have to use a SWD Debugger.

Contribute

Head to the forums to get involved and improve this project. Join the Discord for real-time support and chat

License

The software is released under the GNU General Public License version 3.0

DarkFlippers/unleashed-firmware

Flipper Zero Unleashed Firmware

This firmware is a fork of the original (OFW) version of flipperdevices/flipperzero-firmware and represents the most stable custom build, incorporating new features and improvements to the original components while remaining fully compatible with the API and applications of the original firmware.

Warning

This software is intended solely for experimental purposes and is not meant for any illegal activities. We do not condone unlawful behavior and strongly encourage you to use it only within the bounds of the law.

This project is developed independently and is not affiliated with Flipper Devices.

Also be aware, DarkFlippers/unleashed-firmware is the only official page of the project, there is no paid, premium or closed source versions and if someone contacts you and say they are from our team and try to offer something like that - they are scammers, block that user ASAP

🚀 Usage

Before getting started:

Review the Official Documentation: docs.flipper.net
Installation Guide & Version Info:
How to install the firmware by following the Installation Guide and check the version information (e, , c)
FAQ:
Find answers to common questions in the FAQ
Web Installer: -> Unleashed FW Web Installer

📦 Releases

Release builds (stable)

Telegram: t.me/unleashed_fw
GitHub Releases

Dev builds (unstable)

Note

Built automatically from dev branch

Web site: dev.unleashedflip.com
Telegram: t.me/kotnehleb

🆕 What's New

Sub‑GHz Library & HAL

Many new protocols added

Regional TX restrictions removed

Extra Sub-GHz frequencies added

Frequency range can be extended in settings file (warning: It can damage Flipper's hardware)

Many rolling code protocols now have the ability to save & send captured signals

FAAC SLH (Spa) & BFT Mitto (keeloq secure with seed) manual creation

External CC1101 module support (by quen0n)

Sub‑GHz Main App

Save last used settings (by derskythe)

New frequency analyzer (by ClusterM)

Press OK in frequency analyzer to use detected frequency in Read modes (by derskythe)

Long press OK button in Sub-GHz Frequency analyzer to switch to Read menu (by derskythe)

New option to use timestamps + protocol name when you saving file, instead of random name or timestamp only - Enable in Radio Settings -> Protocol Names = ON

Read mode UI improvements (shows time when signal was received) (by @wosk)

External CC1101 module support (Hardware SPI used)

External CC1101 module amplifier control (or LED control) support (enabled by default)

Hold right in received signal list to delete selected signal

Custom buttons for Keeloq / Alutech AT4N / Nice Flor S / Somfy Telis / Security+ 2.0 / CAME Atomo - now you can use arrow buttons to send signal with different button code

Add manually menu extended with new protocols

FAAC SLH, BFT Mitto / Somfy Telis / Nice Flor S / CAME Atomo, etc. manual creation with programming new remote into receiver (use button 0xF for BFT Mitto, 0x8 (Prog) on Somfy Telis, (right arrow button for other protocols))

Debug mode counter increase settings (+1 → +5, +10, default: +1)

Debug PIN output settings for protocol development

Ignore options - Alarms: Hollarm, GangQi | ReversRB2: Revers RB-2(M) protocol | Sensors: Magellan, Honeywell Sec, Honeywell WDB (doorbells), Legrand (doorbells), Feron (RGB lights) | NiceFlorS: Nice Flor-S protocol

Sub‑GHz Apps (by Unleashed Team)

Sub-GHz Bruteforce - static code brute-force plugin

Time delay (between signals) setting (hold Up in main screen (says Up to Save)) + configure repeats in protocols list by pressing right button on selected protocol

Load your own file and select bytes you want to bruteforce or use preconfigured options in protocols list

Sub-GHz Remote - remote control for 5 sub-ghz files | bind one file for each button

use the built-in constructor or make config file by following this instruction

Infrared (IR)

Recompiled IR TV Universal Remote for ALL buttons

Universal remotes for Projectors, Fans, A/Cs and Audio(soundbars, etc.) → Also always updated and verified by our team

Infrared → RCA Protocol

Infrared → External IR modules support (with autodetect by OFW)

NFC/RFID/iButton

LFRFID and iButton Fuzzer plugins

Add DEZ 8 display form for EM4100 (by @korden32)

Extra Mifare Classic keys in system dict

EMV Protocol + Public data parser (by @Leptopt1los and @wosk)

NFC Add manually → Mifare Classic with custom UID

NFC parsers: Umarsh, Zolotaya Korona, Kazan, Metromoney, Moscow Social Card, Troika (reworked) and many others (by @Leptopt1los and @assasinfil)

Quality of Life & Other Features

Customizable Flipper name Update! Now can be changed in Settings → Desktop (by @xMasterX and @Willy-JL)

Text Input UI element → Cursor feature (by @Willy-JL)

Byte Input Mini editor → Press UP multiple times until the nibble editor appears (by @gid9798)

Clock on Desktop Settings -> Desktop -> Show Clock (by @gid9798)

Battery percentage display with different styles Settings -> Desktop -> Battery View

More games in Dummy Mode → click or hold any of arrow buttons

Lock device with pin (or regular lock if pin not set) by holding UP button on main screen (by an4tur0r)

BadKB (BadUSB) (by Willy-JL, ClaraCrazy, XFW contributors) - (Integrated into BadUSB app now!) - (aka BadUSB via Bluetooth)

BadUSB → Keyboard layouts (by rien > dummy-decoy)

Custom community plugins and games added + all known working apps can be downloaded in extra pack in every release

Other small fixes and changes throughout

See other changes in readme below

Also check the changelog in releases for latest updates!

Current modified and new Sub-GHz protocols list:

Full list of supported protocols and their frequencies/modulations (to use in Read mode)

Thanks to Official team (to their SubGHz Developer, Skorp) for implementing support (decoder + encoder / or decode only) for most protocols in OFW.

And thanks to our contributors who took part in SubGHz improvements and making of new features:

@RocketGod-git, @zero-mega, @ashphx, @pkooiman, Vitaly, Carlos, @li0ard, @mishamyte, d82k, Steffen (bastelbudenbuben de), @assasinfil, @gid9798

❤️ Please support development of the project

The majority of this project is developed and maintained by me, @xMasterX. Our team is small and the guys are working on this project as much as they can solely based on the enthusiasm they have for this project and the community.

@mishamyte - NFC, RFID, SubGHz and chats moderation
@quen0n - Hardware, SubGHz and chats moderation
@Drone1950 - Reverse Engineering, telegram bot and chats moderation
@HackcatDev - Support and chats moderation
@Leptopt1los - NFC, RFID, Plugins, chat moderation and many other things
@gid9798 - SubGHz, Plugins, many other things - currently offline 😦
@assasinfil - SubGHz protocols, NFC parsers, chat moderation
@Svaarich - UI design and animations
@amec0e - Infrared assets
Community moderators in Telegram, Discord, and Reddit
And of course our GitHub community. Your PRs are a very important part of this firmware and open-source development.

The amount of work done on this project is huge and we need your support, no matter how large or small. Even if you just say, "Thank you Unleashed firmware developers!" somewhere. Doing so will help us continue our work and will help drive us to make the firmware better every time. Also, regarding our releases, every build has and always will be free and open-source. There will be no paywall releases or closed-source apps within the firmware. As long as I am working on this project it will never happen.
You can support us by using links or addresses below:

Service	Remark	Link/Wallet
Patreon		patreon.com/mmxdev
Boosty	patreon alternative	boosty.to/mmxdev
CloudTips	only RU payments accepted	pay.cloudtips.ru/p/7b3e9d65
YooMoney	only RU payments accepted	yoomoney.ru/fundraise/XA49mgQLPA0.221209
USDT	TRC20	`TSXcitMSnWXUFqiUfEXrTVpVewXy2cYhrs`
ETH	BSC/ERC20-Tokens	`0xFebF1bBc8229418FF2408C07AF6Afa49152fEc6a`
BTC		`bc1q0np836jk9jwr4dd7p6qv66d04vamtqkxrecck9`
SOL	Solana/Tokens	`DSgwouAEgu8iP5yr7EHHDqMNYWZxAqXWsTEeqCAXGLj8`
DOGE		`D6R6gYgBn5LwTNmPyvAQR6bZ9EtGgFCpvv`
LTC		`ltc1q3ex4ejkl0xpx3znwrmth4lyuadr5qgv8tmq8z9`
BCH		`qquxfyzntuqufy2dx0hrfr4sndp0tucvky4sw8qyu3`
XMR	Monero	`41xUz92suUu1u5Mu4qkrcs52gtfpu9rnZRdBpCJ244KRHf6xXSvVFevdf2cnjS7RAeYr5hn9MsEfxKoFDRSctFjG5fv1Mhn`
TON		`UQCOqcnYkvzOZUV_9bPE_8oTbOrOF03MnF-VcJyjisTZmsxa`

📱 Community Apps

Enhance your Flipper Zero with apps and plugins created by the community:

Extra Plugins & Packs:
Check out the latest extra plugins and plugin packs (Extra Pack and Base Pack) on GitHub.
Source Code & Full List:
Find the complete list and source code at xMasterX/all-the-plugins.
Official Apps Catalog:
Browse the official Flipper Zero Apps Catalog on the web or via the mobile app.

📁 Where I can find IR, Sub-GHz, ... files, DBs, and other stuff?

📘 Instructions

Firmware & main Apps feature

System: How to change Flipper name
BadUSB: How to add new keyboard layouts
Infrared: How to make captures to add them into Universal IR remotes

Sub-GHz

Full list of supported protocols and their frequencies/modulations (to use in Read mode)
How to use Flipper as rolling code remote (Doorhan, Nice FlorS, BFT Mitto, Somfy Telis, Aprimatic, AN-Motors, etc..)
Experimental rolling code counter modes (avoid desync)
External Radio: How to connect CC1101 module
Transmission is blocked? How to extend Sub-GHz frequency range
How to add extra Sub-GHz frequencies
~~Configure Sub-GHz Remote App~~ ⚠️ Not recommended, please use embedded configurator

Plugins

TOTP (Authenticator): config description
Barcode Generator: How to use
Multi Converter: How to use
WAV Player: sample files & how to convert
Sub-GHz playlist: generator script

GPIO - Plugins that works with external hardware

Unitemp - Temperature sensors reader: How to use & supported sensors
[NMEA] GPS: How to use
i2c Tools How to use
[NRF24] plugins: How to use
[WiFi] Scanner: How to use | Web Flasher
[ESP8266] Deauther: How to use | Web Flasher
[ESP32] WiFi Marauder: How to use_{docs by UberGuidoZ} | Marauder repo
[ESP32-CAM] Camera Suite: How to use
How to Upload .bin to ESP32/ESP8266: Windows | FAP "ESP flasher"
[GPIO] SentrySafe plugin: How to use

👨‍💻 Firmware & Development

Developer Documentation - developer.flipper.net
How to build | Project-structure
CLion IDE - How to setup workspace for flipper firmware development by Savely Krasovsky
"Hello world!" - plugin tutorial English_{by DroomOne} | Russian_{by Pavel Yakovlev}
How to write your own app.

Project structure

applications - Applications and services used in firmware
assets - Assets used by applications and services
furi - Furi Core: OS-level primitives and helpers
debug - Debug tool: GDB-plugins, SVD-file and etc
documentation - Documentation generation system configs and input files
firmware - Firmware source code
lib - Our and 3rd party libraries, drivers and etc...
site_scons - Build helpers
scripts - Supplementary scripts and python libraries home

Also, pay attention to the ReadMe.md files inside those directories.

🔗 Links

Unleashed web page: flipperunleashed.com
Unleashed FW Web Installer: web.unleashedflip.com
Unleashed domain used for direct .tgz update links for web updater or direct download: unleashedflip.com
Unleashed directory json for ufbt builds: up.unleashedflip.com/directory.json
Official Docs: docs.flipper.net
Official Forum: forum.flipperzero.one
Update! Official Developer Documentation developer.flipper.net

Cisco-Talos/clamav

ClamAV - Documentation is here: https://docs.clamav.net

ClamAV

ClamAV® is an open source antivirus engine for detecting trojans, viruses, malware & other malicious threats.

Documentation & FAQ

ClamAV documentation is hosted at docs.clamav.net. The source archive for each release also includes a copy of the documentation for offline reading.

You can contribute to the documentation by submitting improvements to Cisco-Talos/clamav-documentation

ClamAV News

For information about the features in this and prior releases, read the news.

Catch up on the latest about ClamAV by reading our blog and follow us on Twitter @clamav.

ClamAV Signatures

Anyone can learn to read and write ClamAV signatures. To get started, see our signature writing manual.

Installation Instructions

Using Docker

ClamAV can be run using Docker. For details, visit to the online manual under "Docker" and check out our images on Docker Hub.

Using a Package Manager

For help installing from a package manager, refer to the online manual under "Packages".

Using an Installer

The following install packages are available for download from clamav.net/downloads:

Linux - Debian and RPM packages for x86_64 and i686. New in v0.104.
macOS - PKG installer for x86_64 and arm64 (universal). New in v0.104.
Windows - MSI installers and portable ZIP packages for win32 and x64.

To learn how to use these packages, refer to the online manual under "Installing".

Build from Source

For step-by-step instructions, refer to the online manual:

The source archive for each release includes a copy of the documentation for offline reading.

A reference with all of the available build options can be found in the INSTALL.md file.

You can find additional advice for developers in the online manual under "For Developers".

Upgrading from a previous version

Visit the FAQ for tips on how to upgrade from a previous version.

Join the ClamAV Community

The best way to get in touch with the ClamAV community is to join our mailing lists.

You can also join the community on our ClamAV Discord chat server.

Want to make a contribution?

The ClamAV development team welcomes code contributions, improvements to our documentation, and also bug reports.

Thanks for joining us!

Licensing

ClamAV is licensed for public/open source use under the GNU General Public License, Version 2 (GPLv2).

See COPYING.txt for a copy of the license.

3rd Party Code

ClamAV contains a number of components that include code copied in part or in whole from 3rd party projects and whose code is not owned by Cisco and which are licensed differently than ClamAV. These include:

Yara: Apache 2.0 license
- Yara has since switched to the BSD 3-Clause License; Our source is out-of-date and needs to be updated.
7z / lzma: public domain
libclamav's NSIS/NulSoft parser includes:
- zlib: permissive free software license
- bzip2 / libbzip2: BSD-like license
OpenBSD's libc/regex: BSD license
file: BSD license
str.c: Contains BSD licensed modified-implementations of strtol(), stroul() functions, Copyright (c) 1990 The Regents of the University of California.
pngcheck (png.c): MIT/X11-style license
getopt.c: MIT license
Curl: license inspired by MIT/X, but not identical
libmspack: LGPL license
UnRAR (libclamunrar): a non-free/restricted open source license
- Note: The UnRAR license is incompatible with GPLv2 because it contains a clause that prohibits reverse engineering a RAR compression algorithm from the UnRAR decompression code. For this reason, libclamunrar/libclamunrar_iface is not linked at all with libclamav. It is instead loaded at run-time. If it fails to load, ClamAV will continue running without RAR support.

See the COPYING directory for a copy of the 3rd party project licenses.

Acknowledgements

Credit for contributions to each release can be found in the News.

ClamAV is brought to you by the ClamAV Team

hathach/tinyusb

An open source cross-platform USB stack for embedded system

TinyUSB

Overview

.. figure:: docs/assets/logo.svg :alt: TinyUSB :align: left

.. raw:: html

TinyUSB is an open-source cross-platform USB Host/Device stack for embedded systems. It’s designed for memory safety (no dynamic allocation) and thread safety (all interrupts deferred to non-ISR task functions). The stack emphasizes portability, small footprint, and real-time performance across 50+ MCU families.

Key Features

Thread-safe: USB interrupts deferred to task context
Memory-safe: No dynamic allocation, all buffers static
Portable: Supports 50+ MCU families
Comprehensive: Includes CDC, HID, MSC, Audio, and Host support
RTOS-friendly: Works with bare metal, FreeRTOS, RT-Thread, and Mynewt

.. figure:: docs/assets/stack.svg :width: 500px :align: left :alt: stackup

.. raw:: html

.
├── docs            # Documentation
├── examples        # Examples with make and cmake build system
├── hw
│   ├── bsp         # Supported boards source files
│   └── mcu         # Low level mcu core & peripheral drivers
├── lib             # Sources from 3rd party such as FreeRTOS, FatFs ...
├── src             # All sources files for TinyUSB stack itself.
├── test            # Tests: unit test, fuzzing, hardware test
└── tools           # Files used internally

Getting started

See the online documentation <https://docs.tinyusb.org>_ for information about using TinyUSB and how it is implemented.

Check out Getting Started_ guide for adding TinyUSB to your project or building the examples. If you are new to TinyUSB, we recommend starting with the cdc_msc example. There is a handful of Supported Boards_ that should work out of the box.

We use GitHub Discussions <https://github.com/hathach/tinyusb/discussions>_ as our forum. It is a great place to ask questions and advice from the community or to discuss your TinyUSB-based projects.

For bugs and feature requests, please raise an issue <https://github.com/hathach/tinyusb/issues>_ and follow the templates there.

See Porting_ guide for adding support for new MCUs and boards.

Device Stack

Supports multiple device configurations by dynamically changing USB descriptors, low power functions such like suspend, resume, and remote wakeup. The following device classes are supported:

Audio Class 1.0/2.0 (UAC1/UAC2)
Bluetooth Host Controller Interface (BTH HCI)
Communication Device Class (CDC)
Device Firmware Update (DFU): DFU mode (WIP) and Runtime
Human Interface Device (HID): Generic (In & Out), Keyboard, Mouse, Gamepad etc ...
Printer class
Mass Storage Class (MSC): with multiple LUNs
Musical Instrument Digital Interface (MIDI)
Media Transfer Protocol (MTP/PTP)
Network with RNDIS, Ethernet Control Model (ECM), Network Control Model (NCM)
Test and Measurement Class (USBTMC)
Video class 1.5 (UVC): work in progress
Vendor-specific class support with generic In & Out endpoints. Can be used with MS OS 2.0 compatible descriptor to load winUSB driver without INF file.
WebUSB <https://github.com/WICG/webusb>__ with vendor-specific class

If you have a special requirement, usbd_app_driver_get_cb() can be used to write your own class driver without modifying the stack. Here is how the RPi team added their reset interface raspberrypi/pico-sdk#197 <https://github.com/raspberrypi/pico-sdk/pull/197>_

Host Stack

Communication Device Class: CDC-ACM
Vendor serial over USB: FTDI, CP210x, CH34x, PL2303
Human Interface Device (HID): Keyboard, Mouse, Generic
Mass Storage Class (MSC)
Musical Instrument Digital Interface (MIDI)
Hub with multiple-level support

Similar to the Device Stack, if you have a special requirement, usbh_app_driver_get_cb() can be used to write your own class driver without modifying the stack.

Power Delivery Stack

Power Delivery 3.0 (PD3.0) with USB Type-C support (WIP)
Super early stage, only for testing purpose
Only support STM32 G4

OS Abstraction layer

TinyUSB is completely thread-safe by pushing all Interrupt Service Request (ISR) events into a central queue, then processing them later in the non-ISR context task function. It also uses semaphore/mutex to access shared resources such as Communication Device Class (CDC) FIFO. Therefore the stack needs to use some of the OS's basic APIs. Following OSes are already supported out of the box.

No OS
FreeRTOS
RT-Thread <https://github.com/RT-Thread/rt-thread>: repo <https://github.com/RT-Thread-packages/tinyusb>
Mynewt Due to the newt package build system, Mynewt examples are better to be on its own repo <https://github.com/hathach/mynewt-tinyusb-example>_

Supported CPUs

+--------------+-----------------------------+--------+------+-----------+------------------------+--------------------+ | Manufacturer | Family | Device | Host | Highspeed | Driver | Note | +==============+=============================+========+======+===========+========================+====================+ | Allwinner | F1C100s/F1C200s | ✔ | | ✔ | sunxi | musb variant | +--------------+-----------------------------+--------+------+-----------+------------------------+--------------------+ | Analog | MAX3421E | | ✔ | ✖ | max3421 | via SPI | | +-----------------------------+--------+------+-----------+------------------------+--------------------+ | | MAX32 650, 666, 690, | ✔ | | ✔ | musb | 1-dir ep | | | MAX78002 | | | | | | +--------------+-----------------------------+--------+------+-----------+------------------------+--------------------+ | Artery AT32 | F403a_407, F413 | ✔ | | | fsdev | 512 USB RAM | | +-----------------------------+--------+------+-----------+------------------------+--------------------+ | | F415, F435_437, F423, | ✔ | ✔ | | dwc2 | | | | F425, F45x | | | | | | | +-----------------------------+--------+------+-----------+------------------------+--------------------+ | | F402_F405 | ✔ | ✔ | ✔ | dwc2 | F405 is HS | +--------------+-----------------------------+--------+------+-----------+------------------------+--------------------+ | Bridgetek | FT90x | ✔ | | ✔ | ft9xx | 1-dir ep | +--------------+-----------------------------+--------+------+-----------+------------------------+--------------------+ | Broadcom | BCM2711, BCM2837 | ✔ | | ✔ | dwc2 | | +--------------+-----------------------------+--------+------+-----------+------------------------+--------------------+ | Dialog | DA1469x | ✔ | ✖ | ✖ | da146xx | | +--------------+-----------------------------+--------+------+-----------+------------------------+--------------------+ | Espressif | S2, S3, H4 | ✔ | ✔ | ✖ | dwc2 | | | ESP32 +-----------------------------+--------+------+-----------+------------------------+--------------------+ | | P4 | ✔ | ✔ | ✔ | dwc2 | | +--------------+-----------------------------+--------+------+-----------+------------------------+--------------------+ | GigaDevice | GD32VF103 | ✔ | | ✖ | dwc2 | | +--------------+-----------------------------+--------+------+-----------+------------------------+--------------------+ | HPMicro | HPM6750 | ✔ | ✔ | ✔ | ci_hs, ehci | | +--------------+-----------------------------+--------+------+-----------+------------------------+--------------------+ | Infineon | XMC4500 | ✔ | ✔ | ✖ | dwc2 | | +--------------+-----+-----------------------+--------+------+-----------+------------------------+--------------------+ | MicroChip | SAM | D11, D21, L21, L22 | ✔ | | ✖ | samd | | | | +-----------------------+--------+------+-----------+------------------------+--------------------+ | | | D51, E5x | ✔ | | ✖ | samd | | | | +-----------------------+--------+------+-----------+------------------------+--------------------+ | | | G55 | ✔ | | ✖ | samg | 1-dir ep | | | +-----------------------+--------+------+-----------+------------------------+--------------------+ | | | E70,S70,V70,V71 | ✔ | | ✔ | samx7x | 1-dir ep | | +-----+-----------------------+--------+------+-----------+------------------------+--------------------+ | | PIC | 24 | ✔ | | | pic | ci_fs variant | | | +-----------------------+--------+------+-----------+------------------------+--------------------+ | | | 32 mm, mk, mx | ✔ | | | pic | ci_fs variant | | | +-----------------------+--------+------+-----------+------------------------+--------------------+ | | | dsPIC33 | ✔ | | | pic | ci_fs variant | | | +-----------------------+--------+------+-----------+------------------------+--------------------+ | | | 32mz | ✔ | | | pic32mz | musb variant | +--------------+-----+-----------------------+--------+------+-----------+------------------------+--------------------+ | MindMotion | mm32 | ✔ | | ✖ | mm32f327x_otg | ci_fs variant | +--------------+-----+-----------------------+--------+------+-----------+------------------------+--------------------+ | NordicSemi | nRF52, nRF53 | ✔ | ✖ | ✖ | nrf5x | only ep8 is ISO | | +-----------------------------+--------+------+-----------+------------------------+--------------------+ | | nRF54 | ✔ | ✖ | ✔ | dwc2 | | +--------------+-----------------------------+--------+------+-----------+------------------------+--------------------+ | Nuvoton | NUC120 | ✔ | ✖ | ✖ | nuc120 | | | +-----------------------------+--------+------+-----------+------------------------+--------------------+ | | NUC121/NUC125, NUC126 | ✔ | ✖ | ✖ | nuc121 | | | +-----------------------------+--------+------+-----------+------------------------+--------------------+ | | NUC505 | ✔ | | ✔ | nuc505 | | +--------------+---------+-------------------+--------+------+-----------+------------------------+--------------------+ | NXP | iMXRT | RT 10xx, 11xx | ✔ | ✔ | ✔ | ci_hs, ehci | | | +---------+-------------------+--------+------+-----------+------------------------+--------------------+ | | Kinetis | KL | ✔ | ⚠ | ✖ | ci_fs, khci | | | | +-------------------+--------+------+-----------+------------------------+--------------------+ | | | K32L2 | ✔ | | ✖ | khci | ci_fs variant | | +---------+-------------------+--------+------+-----------+------------------------+--------------------+ | | LPC | 11u, 13, 15 | ✔ | ✖ | ✖ | lpc_ip3511 | | | | +-------------------+--------+------+-----------+------------------------+--------------------+ | | | 17, 40 | ✔ | ⚠ | ✖ | lpc17_40, ohci | | | | +-------------------+--------+------+-----------+------------------------+--------------------+ | | | 18, 43 | ✔ | ✔ | ✔ | ci_hs, ehci | | | | +-------------------+--------+------+-----------+------------------------+--------------------+ | | | 51u | ✔ | ✖ | ✖ | lpc_ip3511 | | | | +-------------------+--------+------+-----------+------------------------+--------------------+ | | | 54 | ⚠ | ⚠ | ✔ | lpc_ip3511, lpc_ip3516 | NRND, read errata | | | +-------------------+--------+------+-----------+------------------------+--------------------+ | | | 55 | ✔ | ✔ | ✔ | lpc_ip3511, lpc_ip3516 | | | +---------+-------------------+--------+------+-----------+------------------------+--------------------+ | | MCX | N9 | ✔ | | ✔ | ci_fs, ci_hs, ehci | | | | +-------------------+--------+------+-----------+------------------------+--------------------+ | | | A15 | ✔ | | | ci_fs | | | +---------+-------------------+--------+------+-----------+------------------------+--------------------+ | | RW61x | ✔ | ✔ | ✔ | ci_hs, ehci | | +--------------+-----------------------------+--------+------+-----------+------------------------+--------------------+ | Raspberry Pi | RP2040, RP2350 | ✔ | ✔ | ✖ | rp2040, pio_usb | | +--------------+-----+-----------------------+--------+------+-----------+------------------------+--------------------+ | Renesas | RX | 63N, 65N, 72N | ✔ | ✔ | ✖ | rusb2 | | | +-----+-----------------------+--------+------+-----------+------------------------+--------------------+ | | RA | 4M1, 4M3, 6M1 | ✔ | ✔ | ✖ | rusb2 | | | | +-----------------------+--------+------+-----------+------------------------+--------------------+ | | | 6M5 | ✔ | ✔ | ✔ | rusb2 | | +--------------+-----+-----------------------+--------+------+-----------+------------------------+--------------------+ | Silabs | EFM32GG12 | ✔ | | ✖ | dwc2 | | +--------------+-----------------------------+--------+------+-----------+------------------------+--------------------+ | Sony | CXD56 | ✔ | ✖ | ✔ | cxd56 | | +--------------+-----------------------------+--------+------+-----------+------------------------+--------------------+ | ST STM32 | F0, F3, L0, L1, L5, WBx5 | ✔ | ✖ | ✖ | stm32_fsdev | | | +----+------------------------+--------+------+-----------+------------------------+--------------------+ | | F1 | 102, 103 | ✔ | ✖ | ✖ | stm32_fsdev | 512 USB RAM | | | +------------------------+--------+------+-----------+------------------------+--------------------+ | | | 105, 107 | ✔ | ✔ | ✖ | dwc2 | | | +----+------------------------+--------+------+-----------+------------------------+--------------------+ | | F2, F4, F7, H7, H7RS | ✔ | ✔ | ✔ | dwc2 | | | +-----------------------------+--------+------+-----------+------------------------+--------------------+ | | C0, G0, H5, U3 | ✔ | ✔ | ✖ | stm32_fsdev | 2KB USB RAM | | +-----------------------------+--------+------+-----------+------------------------+--------------------+ | | G4 | ✔ | ✖ | ✖ | stm32_fsdev | 1KB USB RAM | | +----+------------------------+--------+------+-----------+------------------------+--------------------+ | | L4 | 4x2, 4x3 | ✔ | ✖ | ✖ | stm32_fsdev | 1KB USB RAM | | | +------------------------+--------+------+-----------+------------------------+--------------------+ | | | 4x5, 4x6, 4+ | ✔ | ✔ | ✖ | dwc2 | | | +----+------------------------+--------+------+-----------+------------------------+--------------------+ | | N6 | ✔ | ✔ | ✔ | dwc2 | | | +-----------------------------+--------+------+-----------+------------------------+--------------------+ | | U0 | ✔ | ✖ | ✖ | stm32_fsdev | 1KB USB RAM | | +----+------------------------+--------+------+-----------+------------------------+--------------------+ | | U5 | 535, 545 | ✔ | ✔ | ✖ | stm32_fsdev | 2KB USB RAM | | | +------------------------+--------+------+-----------+------------------------+--------------------+ | | | 575, 585 | ✔ | ✔ | ✖ | dwc2 | | | | +------------------------+--------+------+-----------+------------------------+--------------------+ | | | 59x,5Ax,5Fx,5Gx | ✔ | ✔ | ✔ | dwc2 | | +--------------+----+------------------------+--------+------+-----------+------------------------+--------------------+ | TI | MSP430 | ✔ | ✖ | ✖ | msp430x5xx | | | +-----------------------------+--------+------+-----------+------------------------+--------------------+ | | MSP432E4, TM4C123 | ✔ | | ✖ | musb | | +--------------+-----------------------------+--------+------+-----------+------------------------+--------------------+ | ValentyUSB | eptri | ✔ | ✖ | ✖ | eptri | | +--------------+-----------------------------+--------+------+-----------+------------------------+--------------------+ | WCH | CH32F20x | ✔ | | ✔ | ch32_usbhs | | | +-----------------------------+--------+------+-----------+------------------------+--------------------+ | | CH32V20x | ✔ | | ✖ | stm32_fsdev/ch32_usbfs | | | +-----------------------------+--------+------+-----------+------------------------+--------------------+ | | CH32V305, CH32V307 | ✔ | | ✔ | ch32_usbfs/hs | | +--------------+-----------------------------+--------+------+-----------+------------------------+--------------------+

Table Legend ^^^^^^^^^^^^

========= ========================= ✔ Supported ⚠ Partial support ✖ Not supported by hardware [empty] Unknown ========= =========================

Development Tools

The following tools are provided freely to support the development of the TinyUSB project:

IAR Build Tools (CX) <https://iar.com>_ Professional IDE and compiler for embedded development.
JetBrains CLion <https://www.jetbrains.com/clion/>_ Cross-platform IDE for C and C++ development.
PVS-Studio <https://pvs-studio.com/en/pvs-studio/?utm_source=website&utm_medium=github&utm_campaign=open_source>_ static analyzer for C, C++, C#, and Java code.

.. |Build Status| image:: https://github.com/hathach/tinyusb/actions/workflows/build.yml/badge.svg :target: https://github.com/hathach/tinyusb/actions/workflows/build.yml .. |CircleCI Status| image:: https://dl.circleci.com/status-badge/img/circleci/4AYHvUhFxdnY4rA7LEsdqW/QmrpoL2AjGqetvFQNqtWyq/tree/master.svg?style=svg :target: https://dl.circleci.com/status-badge/redirect/circleci/4AYHvUhFxdnY4rA7LEsdqW/QmrpoL2AjGqetvFQNqtWyq/tree/master .. |Documentation Status| image:: https://readthedocs.org/projects/tinyusb/badge/?version=latest :target: https://docs.tinyusb.org/en/latest/?badge=latest .. |Static Analysis| image:: https://github.com/hathach/tinyusb/actions/workflows/static_analysis.yml/badge.svg :target: https://github.com/hathach/tinyusb/actions/workflows/static_analysis.yml .. |Fuzzing Status| image:: https://oss-fuzz-build-logs.storage.googleapis.com/badges/tinyusb.svg :target: https://oss-fuzz-build-logs.storage.googleapis.com/index.html#tinyusb .. |Membrowse| image:: https://membrowse.com/badge.svg :target: https://membrowse.com/public/hathach/tinyusb .. |License| image:: https://img.shields.io/badge/license-MIT-brightgreen.svg :target: https://opensource.org/licenses/MIT

.. _Changelog: docs/info/changelog.rst .. _Contributors: CONTRIBUTORS.rst .. _Getting Started: docs/getting_started.rst .. _Supported Boards: docs/reference/boards.rst .. _Dependencies: docs/reference/dependencies.rst .. _Concurrency: docs/reference/concurrency.rst .. _Code of Conduct: CODE_OF_CONDUCT.rst .. _Porting: docs/porting.rst

jqlang/jq

Command-line JSON processor

jq

jq is a lightweight and flexible command-line JSON processor akin to sed,awk,grep, and friends for JSON data. It's written in portable C and has zero runtime dependencies, allowing you to easily slice, filter, map, and transform structured data.

Documentation

Official Documentation: jqlang.org
Try jq Online: play.jqlang.org

Installation

Prebuilt Binaries

Download the latest releases from the GitHub release page.

Docker Image

Pull the jq image to start quickly with Docker.

Run with Docker

Example: Extracting the version from a `package.json` file

docker run --rm -i ghcr.io/jqlang/jq:latest < package.json '.version'

Example: Extracting the version from a `package.json` file with a mounted volume

docker run --rm -i -v "$PWD:$PWD" -w "$PWD" ghcr.io/jqlang/jq:latest '.version' package.json

Building from source

Dependencies

libtool
make
automake
autoconf

Instructions

git submodule update --init    # if building from git to get oniguruma
autoreconf -i                  # if building from git
./configure --with-oniguruma=builtin
make clean                     # if upgrading from a version previously built from source
make -j8
make check
sudo make install

Build a statically linked version:

make LDFLAGS=-all-static

If you're not using the latest git version but instead building a released tarball (available on the release page), skip the autoreconf step, and flex or bison won't be needed.

Cross-Compilation

For details on cross-compilation, check out the GitHub Actions file and the cross-compilation wiki page.

Community & Support

Questions & Help: Stack Overflow (jq tag)
Chat & Community: Join us on Discord
Wiki & Advanced Topics: Explore the Wiki

License

jq is released under the MIT License. jq's documentation is licensed under the Creative Commons CC BY 3.0. jq uses parts of the open source C library "decNumber", which is distributed under ICU License

raspberrypi/linux

Kernel source tree for Raspberry Pi-provided kernel builds. Issues unrelated to the linux kernel should be posted on the community forum at https://forums.raspberrypi.com/

Linux kernel

There are several guides for kernel developers and users. These guides can be rendered in a number of formats, like HTML and PDF. Please read Documentation/admin-guide/README.rst first.

In order to build the documentation, use make htmldocs or make pdfdocs. The formatted documentation can also be read online at:

https://www.kernel.org/doc/html/latest/

There are various text files in the Documentation/ subdirectory, several of them using the Restructured Text markup notation.

Please read the Documentation/process/changes.rst file, as it contains the requirements for building and running the kernel, and information about the problems which may result by upgrading your kernel.

Build status for rpi-6.1.y:

Build status for rpi-6.6.y:

Build status for rpi-6.12.y:

freebsd/freebsd-src

The FreeBSD src tree publish-only repository. Experimenting with 'simple' pull requests....

FreeBSD Source:

This is the top level of the FreeBSD source directory.

FreeBSD is an operating system used to power modern servers, desktops, and embedded platforms. A large community has continually developed it for more than thirty years. Its advanced networking, security, and storage features have made FreeBSD the platform of choice for many of the busiest web sites and most pervasive embedded networking and storage devices.

For copyright information, please see the file COPYRIGHT in this directory. Additional copyright information also exists for some sources in this tree - please see the specific source directories for more information.

The Makefile in this directory supports a number of targets for building components (or all) of the FreeBSD source tree. See build(7), config(8), FreeBSD handbook on building userland, and Handbook for kernels for more information, including setting make(1) variables.

For information on the CPU architectures and platforms supported by FreeBSD, see the FreeBSD website's Platforms page.

For official FreeBSD bootable images, see the release page.

Source Roadmap:

Directory	Description
bin	System/user commands.
cddl	Source code for third-party software under the Common Development and Distribution License.
contrib	Source code for third-party software.
crypto	Source code for cryptographic libraries and commands (see crypto/README).
etc	Template files for /etc.
gnu	Source code for third-party software under the GNU General Public License (GPL) or Lesser General Public License (LGPL). Please see gnu/COPYING and gnu/COPYING.LIB for more information.
include	System include files.
kerberos5	Build system for Kerberos 5 (Heimdal).
krb5	Build system for Kerberos 5 (MIT).
lib	System libraries.
libexec	System commands intended to be executed by other commands or daemons.
release	Makefiles and scripts used for building releases and VM images.
rescue	Build system for statically linked /rescue commands.
sbin	System commands.
secure	Build system for cryptographic libraries and commands (excluding Kerberos).
share	Shared resources.
stand	Boot loader sources.
sys	Kernel sources (see sys/README.md).
targets	Support for experimental `DIRDEPS_BUILD`
tests	Tests which can be run by Kyua. See tests/README for additional information.
tools	Ancillary utilities and tests (not included in the build).
usr.bin	User commands.
usr.sbin	System administration commands.

For information on synchronizing your source tree with one or more of the FreeBSD Project's development branches, please see FreeBSD Handbook.

signalwire/freeswitch

FreeSWITCH is a Software Defined Telecom Stack enabling the digital transformation from proprietary telecom switches to a versatile software implementation that runs on any commodity hardware. From a Raspberry PI to a multi-core server, FreeSWITCH can unlock the telecommunications potential of any device.

FreeSWITCH

Visit https://signalwire.com or https://github.com/signalwire for more info.

Getting Started

FreeSWITCH is available on Github in source code format. You can checkout the development branch and build for many popular platforms including Linux, Windows, MacOSX and BSD. There is an issue tracker and pull request system available as part of the repo online.

See https://developer.signalwire.com/freeswitch/FreeSWITCH-Explained/ for more detailed instructions.

Additional Help

If you need assistance or have an interest in using a commercially supported build, you can contact coreteam@freeswitch.com to learn about professional services to support your project.

Voice-over-IP services - SIP / SMS - App Integrations

SignalWire is the primary sponsor of the FreeSWITCH project and was founded by the original developers of FreeSWITCH. SignalWire provides scalable services to enhance and scale your project such as SMS, SIP, Serverless Application hosting as well as programmable telecom. mod_signalwire which is distributed in this code base allows you to instantly pair with SignalWire and extend your FreeSWITCH.

Documentation

The main index for documentation is available at:

https://freeswitch.org/confluence/

Release notes:

https://freeswitch.org/confluence/display/FREESWITCH/Release+Notes

Install from packages

Step by step tutorials to install FreeSWITCH from packages:

Build from source

Example Dockerfiles to build FreeSWITCH and dependencies from source:

https://github.com/signalwire/freeswitch/tree/master/docker/examples

Step by step tutorials to build FreeSWITCH with provided dependency packages:

Debian [Recommended]
Raspberry Pi
CentOS 7

How to build Debian packages

Using FSDEB

Downloads

Contributions

GitHub pull requests are the recommended way to contribute to the FreeSWITCH source code:

https://github.com/signalwire/freeswitch/pulls

Community

Slack is our chat system where the developers, the FreeSWITCH team, and the most active users are present. This is the place to get answers faster and chat with other users in real time. All you need to do is enter your email and verify it on the Slack signup page and you are ready to join in the discussion!

Slack Community:

https://signalwire.community/

Mailing list (ARCHIVED):

http://lists.freeswitch.org/pipermail/freeswitch-users/

Thank you for using FreeSWITCH!

pgvector/pgvector

Open-source vector similarity search for Postgres

pgvector

Open-source vector similarity search for Postgres

Store your vectors with the rest of your data. Supports:

exact and approximate nearest neighbor search
single-precision, half-precision, binary, and sparse vectors
L2 distance, inner product, cosine distance, L1 distance, Hamming distance, and Jaccard distance
any language with a Postgres client

Plus ACID compliance, point-in-time recovery, JOINs, and all of the other great features of Postgres

Installation

Linux and Mac

Compile and install the extension (supports Postgres 13+)

cd /tmp
git clone --branch v0.8.2 https://github.com/pgvector/pgvector.git
cd pgvector
make
make install # may need sudo

See the installation notes if you run into issues

You can also install it with Docker, Homebrew, PGXN, APT, Yum, pkg, APK, or conda-forge, and it comes preinstalled with Postgres.app and many hosted providers. There are also instructions for GitHub Actions.

Windows

Ensure C++ support in Visual Studio is installed and run x64 Native Tools Command Prompt for VS [version] as administrator. Then use nmake to build:

set "PGROOT=C:\Program Files\PostgreSQL\18"
cd %TEMP%
git clone --branch v0.8.2 https://github.com/pgvector/pgvector.git
cd pgvector
nmake /F Makefile.win
nmake /F Makefile.win install

See the installation notes if you run into issues

You can also install it with Docker or conda-forge.

Getting Started

Enable the extension (do this once in each database where you want to use it)

CREATE EXTENSION vector;

Create a vector column with 3 dimensions

CREATE TABLE items (id bigserial PRIMARY KEY, embedding vector(3));

Insert vectors

INSERT INTO items (embedding) VALUES ('[1,2,3]'), ('[4,5,6]');

Get the nearest neighbors by L2 distance

SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 5;

Also supports inner product (<#>), cosine distance (<=>), and L1 distance (<+>)

Note: <#> returns the negative inner product since Postgres only supports ASC order index scans on operators

Storing

Create a new table with a vector column

CREATE TABLE items (id bigserial PRIMARY KEY, embedding vector(3));

Or add a vector column to an existing table

ALTER TABLE items ADD COLUMN embedding vector(3);

Also supports half-precision, binary, and sparse vectors

Insert vectors

INSERT INTO items (embedding) VALUES ('[1,2,3]'), ('[4,5,6]');

Or load vectors in bulk using COPY (example)

COPY items (embedding) FROM STDIN WITH (FORMAT BINARY);

Upsert vectors

INSERT INTO items (id, embedding) VALUES (1, '[1,2,3]'), (2, '[4,5,6]')
    ON CONFLICT (id) DO UPDATE SET embedding = EXCLUDED.embedding;

Update vectors

UPDATE items SET embedding = '[1,2,3]' WHERE id = 1;

Delete vectors

DELETE FROM items WHERE id = 1;

Querying

Get the nearest neighbors to a vector

SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 5;

Supported distance functions are:

<-> - L2 distance
<#> - (negative) inner product
<=> - cosine distance
<+> - L1 distance
<~> - Hamming distance (binary vectors)
<%> - Jaccard distance (binary vectors)

Get the nearest neighbors to a row

SELECT * FROM items WHERE id != 1 ORDER BY embedding <-> (SELECT embedding FROM items WHERE id = 1) LIMIT 5;

Get rows within a certain distance

SELECT * FROM items WHERE embedding <-> '[3,1,2]' < 5;

Note: Combine with ORDER BY and LIMIT to use an index

Distances

Get the distance

SELECT embedding <-> '[3,1,2]' AS distance FROM items;

For inner product, multiply by -1 (since <#> returns the negative inner product)

SELECT (embedding <#> '[3,1,2]') * -1 AS inner_product FROM items;

For cosine similarity, use 1 - cosine distance

SELECT 1 - (embedding <=> '[3,1,2]') AS cosine_similarity FROM items;

Aggregates

Average vectors

SELECT AVG(embedding) FROM items;

Average groups of vectors

SELECT category_id, AVG(embedding) FROM items GROUP BY category_id;

Indexing

By default, pgvector performs exact nearest neighbor search, which provides perfect recall.

You can add an index to use approximate nearest neighbor search, which trades some recall for speed. Unlike typical indexes, you will see different results for queries after adding an approximate index.

Supported index types are:

HNSW
IVFFlat

HNSW

An HNSW index creates a multilayer graph. It has better query performance than IVFFlat (in terms of speed-recall tradeoff), but has slower build times and uses more memory. Also, an index can be created without any data in the table since there isn’t a training step like IVFFlat.

Add an index for each distance function you want to use.

L2 distance

CREATE INDEX ON items USING hnsw (embedding vector_l2_ops);

Note: Use halfvec_l2_ops for halfvec and sparsevec_l2_ops for sparsevec (and similar with the other distance functions)

Inner product

CREATE INDEX ON items USING hnsw (embedding vector_ip_ops);

Cosine distance

CREATE INDEX ON items USING hnsw (embedding vector_cosine_ops);

L1 distance

CREATE INDEX ON items USING hnsw (embedding vector_l1_ops);

Hamming distance

CREATE INDEX ON items USING hnsw (embedding bit_hamming_ops);

Jaccard distance

CREATE INDEX ON items USING hnsw (embedding bit_jaccard_ops);

Supported types are:

vector - up to 2,000 dimensions
halfvec - up to 4,000 dimensions
bit - up to 64,000 dimensions
sparsevec - up to 1,000 non-zero elements

Index Options

Specify HNSW parameters

m - the max number of connections per layer (16 by default)
ef_construction - the size of the dynamic candidate list for constructing the graph (64 by default)

CREATE INDEX ON items USING hnsw (embedding vector_l2_ops) WITH (m = 16, ef_construction = 64);

A higher value of ef_construction provides better recall at the cost of index build time / insert speed.

Query Options

Specify the size of the dynamic candidate list for search (40 by default)

SET hnsw.ef_search = 100;

A higher value provides better recall at the cost of speed.

Use SET LOCAL inside a transaction to set it for a single query

BEGIN;
SET LOCAL hnsw.ef_search = 100;
SELECT ...
COMMIT;

Index Build Time

Indexes build significantly faster when the graph fits into maintenance_work_mem

SET maintenance_work_mem = '8GB';

A notice is shown when the graph no longer fits

NOTICE:  hnsw graph no longer fits into maintenance_work_mem after 100000 tuples
DETAIL:  Building will take significantly more time.
HINT:  Increase maintenance_work_mem to speed up builds.

Note: Do not set maintenance_work_mem so high that it exhausts the memory on the server

Like other index types, it’s faster to create an index after loading your initial data

You can also speed up index creation by increasing the number of parallel workers (2 by default)

SET max_parallel_maintenance_workers = 7; -- plus leader

For a large number of workers, you may need to increase max_parallel_workers (8 by default)

The index options also have a significant impact on build time (use the defaults unless seeing low recall)

Indexing Progress

Check indexing progress

SELECT phase, round(100.0 * blocks_done / nullif(blocks_total, 0), 1) AS "%" FROM pg_stat_progress_create_index;

The phases for HNSW are:

initializing
loading tuples

IVFFlat

An IVFFlat index divides vectors into lists, and then searches a subset of those lists that are closest to the query vector. It has faster build times and uses less memory than HNSW, but has lower query performance (in terms of speed-recall tradeoff).

Three keys to achieving good recall are:

Create the index after the table has some data
Choose an appropriate number of lists - a good place to start is rows / 1000 for up to 1M rows and sqrt(rows) for over 1M rows
When querying, specify an appropriate number of probes (higher is better for recall, lower is better for speed) - a good place to start is sqrt(lists)

Add an index for each distance function you want to use.

L2 distance

CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops) WITH (lists = 100);

Note: Use halfvec_l2_ops for halfvec (and similar with the other distance functions)

Inner product

CREATE INDEX ON items USING ivfflat (embedding vector_ip_ops) WITH (lists = 100);

Cosine distance

CREATE INDEX ON items USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);

Hamming distance

CREATE INDEX ON items USING ivfflat (embedding bit_hamming_ops) WITH (lists = 100);

Supported types are:

vector - up to 2,000 dimensions
halfvec - up to 4,000 dimensions
bit - up to 64,000 dimensions

Query Options

Specify the number of probes (1 by default)

SET ivfflat.probes = 10;

A higher value provides better recall at the cost of speed, and it can be set to the number of lists for exact nearest neighbor search (at which point the planner won’t use the index)

Use SET LOCAL inside a transaction to set it for a single query

BEGIN;
SET LOCAL ivfflat.probes = 10;
SELECT ...
COMMIT;

Index Build Time

Speed up index creation on large tables by increasing the number of parallel workers (2 by default)

SET max_parallel_maintenance_workers = 7; -- plus leader

For a large number of workers, you may also need to increase max_parallel_workers (8 by default)

Indexing Progress

Check indexing progress

SELECT phase, round(100.0 * tuples_done / nullif(tuples_total, 0), 1) AS "%" FROM pg_stat_progress_create_index;

The phases for IVFFlat are:

initializing
performing k-means
assigning tuples
loading tuples

Note: % is only populated during the loading tuples phase

Filtering

There are a few ways to index nearest neighbor queries with a WHERE clause.

SELECT * FROM items WHERE category_id = 123 ORDER BY embedding <-> '[3,1,2]' LIMIT 5;

A good place to start is creating an index on the filter column. This can provide fast, exact nearest neighbor search in many cases. Postgres has a number of index types for this: B-tree (default), hash, GiST, SP-GiST, GIN, and BRIN.

CREATE INDEX ON items (category_id);

For multiple columns, consider a multicolumn index.

CREATE INDEX ON items (location_id, category_id);

Exact indexes work well for conditions that match a low percentage of rows. Otherwise, approximate indexes can work better.

CREATE INDEX ON items USING hnsw (embedding vector_l2_ops);

With approximate indexes, filtering is applied after the index is scanned. If a condition matches 10% of rows, with HNSW and the default hnsw.ef_search of 40, only 4 rows will match on average. For more rows, increase hnsw.ef_search.

SET hnsw.ef_search = 200;

Starting with 0.8.0, you can enable iterative index scans, which will automatically scan more of the index when needed.

SET hnsw.iterative_scan = strict_order;

If filtering by only a few distinct values, consider partial indexing.

CREATE INDEX ON items USING hnsw (embedding vector_l2_ops) WHERE (category_id = 123);

If filtering by many different values, consider partitioning.

CREATE TABLE items (embedding vector(3), category_id int) PARTITION BY LIST(category_id);

Iterative Index Scans

With approximate indexes, queries with filtering can return less results since filtering is applied after the index is scanned. Starting with 0.8.0, you can enable iterative index scans, which will automatically scan more of the index until enough results are found (or it reaches hnsw.max_scan_tuples or ivfflat.max_probes).

Iterative scans can use strict or relaxed ordering.

Strict ensures results are in the exact order by distance

SET hnsw.iterative_scan = strict_order;

Relaxed allows results to be slightly out of order by distance, but provides better recall

SET hnsw.iterative_scan = relaxed_order;
# or
SET ivfflat.iterative_scan = relaxed_order;

With relaxed ordering, you can use a materialized CTE to get strict ordering

WITH relaxed_results AS MATERIALIZED (
    SELECT id, embedding <-> '[1,2,3]' AS distance FROM items WHERE category_id = 123 ORDER BY distance LIMIT 5
) SELECT * FROM relaxed_results ORDER BY distance + 0;

Note: + 0 is needed for Postgres 17+

For queries that filter by distance, use a materialized CTE and place the distance filter outside of it for best performance (due to the current behavior of the Postgres executor)

WITH nearest_results AS MATERIALIZED (
    SELECT id, embedding <-> '[1,2,3]' AS distance FROM items ORDER BY distance LIMIT 5
) SELECT * FROM nearest_results WHERE distance < 5 ORDER BY distance;

Note: Place any other filters inside the CTE

Iterative Scan Options

Since scanning a large portion of an approximate index is expensive, there are options to control when a scan ends.

HNSW

Specify the max number of tuples to visit (20,000 by default)

SET hnsw.max_scan_tuples = 20000;

Note: This is approximate and does not affect the initial scan

Specify the max amount of memory to use, as a multiple of work_mem (1 by default)

SET hnsw.scan_mem_multiplier = 2;

Note: Try increasing this if increasing hnsw.max_scan_tuples does not improve recall

IVFFlat

Specify the max number of probes

SET ivfflat.max_probes = 100;

Note: If this is lower than ivfflat.probes, ivfflat.probes will be used

Half-Precision Vectors

Use the halfvec type to store half-precision vectors

CREATE TABLE items (id bigserial PRIMARY KEY, embedding halfvec(3));

Half-Precision Indexing

Index vectors at half precision for smaller indexes

CREATE INDEX ON items USING hnsw ((embedding::halfvec(3)) halfvec_l2_ops);

Get the nearest neighbors

SELECT * FROM items ORDER BY embedding::halfvec(3) <-> '[1,2,3]' LIMIT 5;

Binary Vectors

Use the bit type to store binary vectors (example)

CREATE TABLE items (id bigserial PRIMARY KEY, embedding bit(3));
INSERT INTO items (embedding) VALUES ('000'), ('111');

Get the nearest neighbors by Hamming distance

SELECT * FROM items ORDER BY embedding <~> '101' LIMIT 5;

Also supports Jaccard distance (<%>)

Binary Quantization

Use expression indexing for binary quantization

CREATE INDEX ON items USING hnsw ((binary_quantize(embedding)::bit(3)) bit_hamming_ops);

Get the nearest neighbors by Hamming distance

SELECT * FROM items ORDER BY binary_quantize(embedding)::bit(3) <~> binary_quantize('[1,-2,3]') LIMIT 5;

Re-rank by the original vectors for better recall

SELECT * FROM (
    SELECT * FROM items ORDER BY binary_quantize(embedding)::bit(3) <~> binary_quantize('[1,-2,3]') LIMIT 20
) ORDER BY embedding <=> '[1,-2,3]' LIMIT 5;

Sparse Vectors

Use the sparsevec type to store sparse vectors

CREATE TABLE items (id bigserial PRIMARY KEY, embedding sparsevec(5));

Insert vectors

INSERT INTO items (embedding) VALUES ('{1:1,3:2,5:3}/5'), ('{1:4,3:5,5:6}/5');

The format is {index1:value1,index2:value2}/dimensions and indices start at 1 like SQL arrays

Get the nearest neighbors by L2 distance

SELECT * FROM items ORDER BY embedding <-> '{1:3,3:1,5:2}/5' LIMIT 5;

Hybrid Search

Use together with Postgres full-text search for hybrid search.

SELECT id, content FROM items, plainto_tsquery('hello search') query
    WHERE textsearch @@ query ORDER BY ts_rank_cd(textsearch, query) DESC LIMIT 5;

You can use Reciprocal Rank Fusion or a cross-encoder to combine results.

Indexing Subvectors

Use expression indexing to index subvectors

CREATE INDEX ON items USING hnsw ((subvector(embedding, 1, 3)::vector(3)) vector_cosine_ops);

Get the nearest neighbors by cosine distance

SELECT * FROM items ORDER BY subvector(embedding, 1, 3)::vector(3) <=> subvector('[1,2,3,4,5]'::vector, 1, 3) LIMIT 5;

Re-rank by the full vectors for better recall

SELECT * FROM (
    SELECT * FROM items ORDER BY subvector(embedding, 1, 3)::vector(3) <=> subvector('[1,2,3,4,5]'::vector, 1, 3) LIMIT 20
) ORDER BY embedding <=> '[1,2,3,4,5]' LIMIT 5;

Performance

Tuning

Use a tool like PgTune to set initial values for Postgres server parameters. For instance, shared_buffers should typically be 25% of the server’s memory. You can find the config file with:

SHOW config_file;

And check individual settings with:

SHOW shared_buffers;

Be sure to restart Postgres for changes to take effect.

Loading

Use COPY for bulk loading data (example).

COPY items (embedding) FROM STDIN WITH (FORMAT BINARY);

Add any indexes after loading the initial data for best performance.

Indexing

See index build time for HNSW and IVFFlat.

In production environments, create indexes concurrently to avoid blocking writes.

CREATE INDEX CONCURRENTLY ...

Querying

Use EXPLAIN (ANALYZE, BUFFERS) to debug performance.

EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 5;

Exact Search

To speed up queries without an index, increase max_parallel_workers_per_gather.

SET max_parallel_workers_per_gather = 4;

If vectors are normalized to length 1 (like OpenAI embeddings), use inner product for best performance.

SELECT * FROM items ORDER BY embedding <#> '[3,1,2]' LIMIT 5;

Approximate Search

To speed up queries with an IVFFlat index, increase the number of inverted lists (at the expense of recall).

CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops) WITH (lists = 1000);

Vacuuming

Vacuuming can take a while for HNSW indexes. Speed it up by reindexing first.

REINDEX INDEX CONCURRENTLY index_name;
VACUUM table_name;

Monitoring

Monitor performance with pg_stat_statements (be sure to add it to shared_preload_libraries).

CREATE EXTENSION pg_stat_statements;

Get the most time-consuming queries with:

SELECT query, calls, ROUND((total_plan_time + total_exec_time) / calls) AS avg_time_ms,
    ROUND((total_plan_time + total_exec_time) / 60000) AS total_time_min
    FROM pg_stat_statements ORDER BY total_plan_time + total_exec_time DESC LIMIT 20;

Monitor recall by comparing results from approximate search with exact search.

BEGIN;
SET LOCAL enable_indexscan = off; -- use exact search
SELECT ...
COMMIT;

Scaling

Scale pgvector the same way you scale Postgres.

Scale vertically by increasing memory, CPU, and storage on a single instance. Use existing tools to tune parameters and monitor performance.

Scale horizontally with replicas, or use Citus or another approach for sharding (example).

Languages

Use pgvector from any language with a Postgres client. You can even generate and store vectors in one language and query them in another.

Language	Libraries / Examples
Ada	pgvector-ada
Algol	pgvector-algol
C	pgvector-c
C++	pgvector-cpp
C#, F#, Visual Basic	pgvector-dotnet
COBOL	pgvector-cobol
Crystal	pgvector-crystal
D	pgvector-d
Dart	pgvector-dart
Elixir	pgvector-elixir
Erlang	pgvector-erlang
Fortran	pgvector-fortran
Gleam	pgvector-gleam
Go	pgvector-go
Haskell	pgvector-haskell
Java, Kotlin, Groovy, Scala	pgvector-java
JavaScript, TypeScript	pgvector-node
Julia	Pgvector.jl
Lisp	pgvector-lisp
Lua	pgvector-lua
Nim	pgvector-nim
OCaml	pgvector-ocaml
Pascal	pgvector-pascal
Perl	pgvector-perl
PHP	pgvector-php
Prolog	pgvector-prolog
Python	pgvector-python
R	pgvector-r
Racket	pgvector-racket
Raku	pgvector-raku
Ruby	pgvector-ruby, Neighbor
Rust	pgvector-rust
Swift	pgvector-swift
Tcl	pgvector-tcl
Zig	pgvector-zig

Frequently Asked Questions

How many vectors can be stored in a single table?

A non-partitioned table has a limit of 32 TB by default in Postgres. A partitioned table can have thousands of partitions of that size.

Is replication supported?

Yes, pgvector uses the write-ahead log (WAL), which allows for replication and point-in-time recovery.

What if I want to index vectors with more than 2,000 dimensions?

You can use half-precision vectors or half-precision indexing to index up to 4,000 dimensions or binary quantization to index up to 64,000 dimensions. Other options are indexing subvectors (for models that support it) or dimensionality reduction.

Can I store vectors with different dimensions in the same column?

You can use vector as the type (instead of vector(n)).

CREATE TABLE embeddings (model_id bigint, item_id bigint, embedding vector, PRIMARY KEY (model_id, item_id));

However, you can only create indexes on rows with the same number of dimensions (using expression and partial indexing):

CREATE INDEX ON embeddings USING hnsw ((embedding::vector(3)) vector_l2_ops) WHERE (model_id = 123);

and query with:

SELECT * FROM embeddings WHERE model_id = 123 ORDER BY embedding::vector(3) <-> '[3,1,2]' LIMIT 5;

Can I store vectors with more precision?

You can use the double precision[] or numeric[] type to store vectors with more precision.

CREATE TABLE items (id bigserial PRIMARY KEY, embedding double precision[]);

-- use {} instead of [] for Postgres arrays
INSERT INTO items (embedding) VALUES ('{1,2,3}'), ('{4,5,6}');

Optionally, add a check constraint to ensure data can be converted to the vector type and has the expected dimensions.

ALTER TABLE items ADD CHECK (vector_dims(embedding::vector) = 3);

Use expression indexing to index (at a lower precision):

CREATE INDEX ON items USING hnsw ((embedding::vector(3)) vector_l2_ops);

and query with:

SELECT * FROM items ORDER BY embedding::vector(3) <-> '[3,1,2]' LIMIT 5;

Do indexes need to fit into memory?

No, but like other index types, you’ll likely see better performance if they do. You can get the size of an index with:

SELECT pg_size_pretty(pg_relation_size('index_name'));

Troubleshooting

Why isn’t a query using an index?

The query needs to have an ORDER BY and LIMIT, and the ORDER BY must be the result of a distance operator (not an expression) in ascending order.

-- index
ORDER BY embedding <=> '[3,1,2]' LIMIT 5;

-- no index
ORDER BY 1 - (embedding <=> '[3,1,2]') DESC LIMIT 5;

You can encourage the planner to use an index for a query with:

BEGIN;
SET LOCAL enable_seqscan = off;
SELECT ...
COMMIT;

Also, if the table is small, a table scan may be faster.

Why isn’t a query using a parallel table scan?

The planner doesn’t consider out-of-line storage in cost estimates, which can make a serial scan look cheaper. You can reduce the cost of a parallel scan for a query with:

BEGIN;
SET LOCAL min_parallel_table_scan_size = 1;
SET LOCAL parallel_setup_cost = 1;
SELECT ...
COMMIT;

or choose to store vectors inline:

ALTER TABLE items ALTER COLUMN embedding SET STORAGE PLAIN;

Why are there less results for a query after adding an HNSW index?

Results are limited by the size of the dynamic candidate list (hnsw.ef_search), which is 40 by default. There may be even less results due to dead tuples or filtering conditions in the query. Enabling iterative index scans can help address this.

Also, note that NULL vectors are not indexed (as well as zero vectors for cosine distance).

Why are there less results for a query after adding an IVFFlat index?

The index was likely created with too little data for the number of lists. Drop the index until the table has more data.

DROP INDEX index_name;

Results can also be limited by the number of probes (ivfflat.probes). Enabling iterative index scans can address this.

Also, note that NULL vectors are not indexed (as well as zero vectors for cosine distance).

Reference

Vector Type

Each vector takes 4 * dimensions + 8 bytes of storage. Each element is a single-precision floating-point number (like the real type in Postgres), and all elements must be finite (no NaN, Infinity or -Infinity). Vectors can have up to 16,000 dimensions.

Vector Operators

Operator	Description	Added
+	element-wise addition
-	element-wise subtraction
*	element-wise multiplication	0.5.0
\|\|	concatenate	0.7.0
<->	Euclidean distance
<#>	negative inner product
<=>	cosine distance
<+>	taxicab distance	0.7.0

Vector Functions

Function	Description	Added
binary_quantize(vector) → bit	binary quantize	0.7.0
cosine_distance(vector, vector) → double precision	cosine distance
inner_product(vector, vector) → double precision	inner product
l1_distance(vector, vector) → double precision	taxicab distance	0.5.0
l2_distance(vector, vector) → double precision	Euclidean distance
l2_normalize(vector) → vector	Normalize with Euclidean norm	0.7.0
subvector(vector, integer, integer) → vector	subvector	0.7.0
vector_dims(vector) → integer	number of dimensions
vector_norm(vector) → double precision	Euclidean norm

Vector Aggregate Functions

Function	Description	Added
avg(vector) → vector	average
sum(vector) → vector	sum	0.5.0

Halfvec Type

Each half vector takes 2 * dimensions + 8 bytes of storage. Each element is a half-precision floating-point number, and all elements must be finite (no NaN, Infinity or -Infinity). Half vectors can have up to 16,000 dimensions.

Halfvec Operators

Operator	Description	Added
+	element-wise addition	0.7.0
-	element-wise subtraction	0.7.0
*	element-wise multiplication	0.7.0
\|\|	concatenate	0.7.0
<->	Euclidean distance	0.7.0
<#>	negative inner product	0.7.0
<=>	cosine distance	0.7.0
<+>	taxicab distance	0.7.0

Halfvec Functions

Function	Description	Added
binary_quantize(halfvec) → bit	binary quantize	0.7.0
cosine_distance(halfvec, halfvec) → double precision	cosine distance	0.7.0
inner_product(halfvec, halfvec) → double precision	inner product	0.7.0
l1_distance(halfvec, halfvec) → double precision	taxicab distance	0.7.0
l2_distance(halfvec, halfvec) → double precision	Euclidean distance	0.7.0
l2_norm(halfvec) → double precision	Euclidean norm	0.7.0
l2_normalize(halfvec) → halfvec	Normalize with Euclidean norm	0.7.0
subvector(halfvec, integer, integer) → halfvec	subvector	0.7.0
vector_dims(halfvec) → integer	number of dimensions	0.7.0

Halfvec Aggregate Functions

Function	Description	Added
avg(halfvec) → halfvec	average	0.7.0
sum(halfvec) → halfvec	sum	0.7.0

Bit Type

Each bit vector takes dimensions / 8 + 8 bytes of storage. See the Postgres docs for more info.

Bit Operators

Operator	Description	Added
<~>	Hamming distance	0.7.0
<%>	Jaccard distance	0.7.0

Bit Functions

Function	Description	Added
hamming_distance(bit, bit) → double precision	Hamming distance	0.7.0
jaccard_distance(bit, bit) → double precision	Jaccard distance	0.7.0

Sparsevec Type

Each sparse vector takes 8 * non-zero elements + 16 bytes of storage. Each element is a single-precision floating-point number, and all elements must be finite (no NaN, Infinity or -Infinity). Sparse vectors can have up to 16,000 non-zero elements.

Sparsevec Operators

Operator	Description	Added
<->	Euclidean distance	0.7.0
<#>	negative inner product	0.7.0
<=>	cosine distance	0.7.0
<+>	taxicab distance	0.7.0

Sparsevec Functions

Function	Description	Added
cosine_distance(sparsevec, sparsevec) → double precision	cosine distance	0.7.0
inner_product(sparsevec, sparsevec) → double precision	inner product	0.7.0
l1_distance(sparsevec, sparsevec) → double precision	taxicab distance	0.7.0
l2_distance(sparsevec, sparsevec) → double precision	Euclidean distance	0.7.0
l2_norm(sparsevec) → double precision	Euclidean norm	0.7.0
l2_normalize(sparsevec) → sparsevec	Normalize with Euclidean norm	0.7.0

Installation Notes - Linux and Mac

Postgres Location

If your machine has multiple Postgres installations, specify the path to pg_config with:

export PG_CONFIG=/Library/PostgreSQL/18/bin/pg_config

Then re-run the installation instructions (run make clean before make if needed). If sudo is needed for make install, use:

sudo --preserve-env=PG_CONFIG make install

A few common paths on Mac are:

EDB installer - /Library/PostgreSQL/18/bin/pg_config
Homebrew (arm64) - /opt/homebrew/opt/postgresql@18/bin/pg_config
Homebrew (x86-64) - /usr/local/opt/postgresql@18/bin/pg_config

Note: Replace 18 with your Postgres server version

Missing Header

If compilation fails with fatal error: postgres.h: No such file or directory, make sure Postgres development files are installed on the server.

For Ubuntu and Debian, use:

sudo apt install postgresql-server-dev-18

Note: Replace 18 with your Postgres server version

Missing SDK

If compilation fails and the output includes warning: no such sysroot directory on Mac, your Postgres installation points to a path that no longer exists.

pg_config --cppflags

Reinstall Postgres to fix this.

Portability

By default, pgvector compiles with -march=native on some platforms for best performance. However, this can lead to Illegal instruction errors if trying to run the compiled extension on a different machine.

To compile for portability, use:

make OPTFLAGS=""

Installation Notes - Windows

Missing Header

If compilation fails with Cannot open include file: 'postgres.h': No such file or directory, make sure PGROOT is correct.

Mismatched Architecture

If compilation fails with error C2196: case value '4' already used, make sure you’re using the x64 Native Tools Command Prompt. Then run nmake /F Makefile.win clean and re-run the installation instructions.

Missing Symbol

If linking fails with unresolved external symbol float_to_shortest_decimal_bufn with Postgres 17.0-17.2, upgrade to Postgres 17.3+.

Permissions

If installation fails with Access is denied, re-run the installation instructions as an administrator.

Additional Installation Methods

Docker

Get the Docker image with:

docker pull pgvector/pgvector:pg18-trixie

This adds pgvector to the Postgres image (replace 18 with your Postgres server version, and run it the same way).

Supported tags are:

pg18-trixie, 0.8.2-pg18-trixie
pg18-bookworm, 0.8.2-pg18-bookworm, pg18, 0.8.2-pg18
pg17-trixie, 0.8.2-pg17-trixie
pg17-bookworm, 0.8.2-pg17-bookworm, pg17, 0.8.2-pg17
pg16-trixie, 0.8.2-pg16-trixie
pg16-bookworm, 0.8.2-pg16-bookworm, pg16, 0.8.2-pg16
pg15-trixie, 0.8.2-pg15-trixie
pg15-bookworm, 0.8.2-pg15-bookworm, pg15, 0.8.2-pg15
pg14-trixie, 0.8.2-pg14-trixie
pg14-bookworm, 0.8.2-pg14-bookworm, pg14, 0.8.2-pg14
pg13-trixie, 0.8.2-pg13-trixie
pg13-bookworm, 0.8.2-pg13-bookworm, pg13, 0.8.2-pg13

You can also build the image manually:

git clone --branch v0.8.2 https://github.com/pgvector/pgvector.git
cd pgvector
docker build --pull --build-arg PG_MAJOR=18 -t myuser/pgvector .

If you increase maintenance_work_mem, make sure --shm-size is at least that size to avoid an error with parallel HNSW index builds.

docker run --shm-size=1g ...

Homebrew

With Homebrew Postgres, you can use:

brew install pgvector

Note: This only adds it to the postgresql@18 and postgresql@17 formulas

PGXN

Install from the PostgreSQL Extension Network with:

pgxn install vector

APT

Debian and Ubuntu packages are available from the PostgreSQL APT Repository. Follow the setup instructions and run:

sudo apt install postgresql-18-pgvector

Note: Replace 18 with your Postgres server version

Yum

RPM packages are available from the PostgreSQL Yum Repository. Follow the setup instructions for your distribution and run:

sudo yum install pgvector_18
# or
sudo dnf install pgvector_18

Note: Replace 18 with your Postgres server version

pkg

Install the FreeBSD package with:

pkg install postgresql17-pgvector

or the port with:

cd /usr/ports/databases/pgvector
make install

APK

Install the Alpine package with:

apk add postgresql-pgvector

conda-forge

With Conda Postgres, install from conda-forge with:

conda install -c conda-forge pgvector

This method is community-maintained by @mmcauliffe

Postgres.app

Download the latest release with Postgres 15+.

Hosted Postgres

pgvector is available on these providers.

Upgrading

Install the latest version (use the same method as the original installation). Then in each database you want to upgrade, run:

ALTER EXTENSION vector UPDATE;

You can check the version in the current database with:

SELECT extversion FROM pg_extension WHERE extname = 'vector';

Thanks

Thanks to:

History

View the changelog

Contributing

Everyone is encouraged to help improve this project. Here are a few ways you can help:

Report bugs
Fix bugs and submit pull requests
Write, clarify, or fix documentation
Suggest or add new features

To get started with development:

git clone https://github.com/pgvector/pgvector.git
cd pgvector
make
make install

To run all tests:

make installcheck        # regression tests
make prove_installcheck  # TAP tests

To run single tests:

make installcheck REGRESS=functions                            # regression test
make prove_installcheck PROVE_TESTS=test/t/001_ivfflat_wal.pl  # TAP test

To enable assertions:

make clean && PG_CFLAGS="-DUSE_ASSERT_CHECKING" make && make install

To enable benchmarking:

make clean && PG_CFLAGS="-DIVFFLAT_BENCH" make && make install

To show memory usage:

make clean && PG_CFLAGS="-DHNSW_MEMORY -DIVFFLAT_MEMORY" make && make install

To get k-means metrics:

make clean && PG_CFLAGS="-DIVFFLAT_KMEANS_DEBUG" make && make install

Resources for contributors

apache/nuttx

Apache NuttX is a mature, real-time embedded operating system (RTOS)

Apache NuttX is a real-time operating system (RTOS) with an emphasis on standards compliance and small footprint. Scalable from 8-bit to 64-bit microcontroller environments, the primary governing standards in NuttX are POSIX and ANSI standards. Additional standard APIs from Unix and other common RTOSs (such as VxWorks) are adopted for functionality not available under these standards, or for functionality that is not appropriate for deeply-embedded environments (such as fork()).

For brevity, many parts of the documentation will refer to Apache NuttX as simply NuttX.

Getting Started

First time on NuttX? Read the Getting Started guide! If you don't have a board available, NuttX has its own simulator that you can run on terminal.

Documentation

You can find the current NuttX documentation on the Documentation Page.

Alternatively, you can build the documentation yourself by following the Documentation Build Instructions.

The old NuttX documentation is still available in the Apache wiki.

Supported Boards

NuttX supports a wide variety of platforms. See the full list on the Supported Platforms page.

Contributing

If you wish to contribute to the NuttX project, read the Contributing guidelines for information on Git usage, coding standard, workflow and the NuttX principles.

License

The code in this repository is under either the Apache 2 license, or a license compatible with the Apache 2 license. See the License Page for more information.

Zaneham/BarraCUDA

Open-source CUDA compiler targeting multiple GPU architectures. Compiles .cu to AMD and Tenstorrent GPU's

BarraCUDA

An open-source CUDA C++ compiler written from scratch in C99 that takes .cu files and compiles them to AMD GPU machine code, NVIDIA PTX, and Tenstorrent Tensix C++, with more architectures planned. No LLVM, no dependencies, and no permission asked.

This is what happens when you look at NVIDIA's walled garden and think "how hard can it be?" The answer is: quite hard, actually, but I did it anyway.

See Changelog for recent updates.

What It Does

Takes CUDA C source code, the same .cu files you'd feed to nvcc, and compiles them to AMD RDNA 2/3/4 binaries, NVIDIA PTX, or Tenstorrent Tensix Metalium C++.

┌───────────────────────────────────────────────────────────────────────────┐
│                          BarraCUDA Pipeline                              │
├───────────────────────────────────────────────────────────────────────────┤
│  Source (.cu)                                                            │
│       ↓                                                                  │
│  Preprocessor → #include, #define, macros, conditionals                  │
│       ↓                                                                  │
│  Lexer → Tokens                                                          │
│       ↓                                                                  │
│  Parser (Recursive Descent) → AST                                        │
│       ↓                                                                  │
│  Semantic Analysis → Type checking, scope resolution                     │
│       ↓                                                                  │
│  BIR (BarraCUDA IR) → SSA form, typed instructions                       │
│       ↓                                                                  │
│  mem2reg → Promotes allocas to SSA registers                             │
│       ↓                                                                  │
│  Instruction Selection                                                   │
│       ├──────────────────┬──────────────────┬────────────────────┤       │
│       ↓ AMD              ↓ NVIDIA            ↓ Tenstorrent       │       │
│  VGPR/SGPR regalloc  PTX isel + emit    Tensix SFPU isel        │       │
│       ↓                  ↓                   ↓                   │       │
│  GFX9/10/11/12       .ptx text          Metalium C++             │       │
│  binary encoding     (driver JIT)       compute/reader/writer    │       │
│       ↓                  ↓                   ↓                   │       │
│  .hsaco ELF          Runs on NVIDIA     Runs on Tenstorrent      │       │
│       ↓              hardware            hardware                │       │
│  Runs on AMD                                                     │       │
│  hardware                                                        │       │
└───────────────────────────────────────────────────────────────────────────┘

Building

# It's C99. It builds with gcc. There are no dependencies.
make

# That's it. No cmake. No autoconf. No 47-step build process.
# If this doesn't work, your gcc is broken, not the Makefile.

Requirements

A C99 compiler (gcc, clang, whatever you've got)
A will to live (optional but recommended)
LLVM is NOT required. BarraCUDA does its own instruction encoding like an adult.

Usage

# Compile to AMD GPU binary (RDNA 3, default)
./barracuda --amdgpu-bin kernel.cu -o kernel.hsaco

# Compile for RDNA 2
./barracuda --amdgpu-bin --gfx1030 kernel.cu -o kernel.hsaco

# Compile for RDNA 4
./barracuda --amdgpu-bin --gfx1200 kernel.cu -o kernel.hsaco

# Compile to NVIDIA PTX
./barracuda --nvidia-ptx kernel.cu -o kernel.ptx

# Compile to Tenstorrent Metalium C++
./barracuda --tensix kernel.cu -o kernel_compute.cpp

# Dump the IR (for debugging or curiosity)
./barracuda --ir kernel.cu

# Just parse and dump the AST
./barracuda --ast kernel.cu

# Run semantic analysis
./barracuda --sema kernel.cu

# Error messages in te reo Maori (or any language with a translation file)
./barracuda --lang lang/mi.txt --amdgpu-bin kernel.cu -o kernel.hsaco

Runtime Launcher

BarraCUDA includes a minimal HSA runtime (src/runtime/) for dispatching compiled kernels on real AMD hardware. Zero compile-time dependency on ROCm — loads libhsa-runtime64.so at runtime via dlopen.

# Compile the runtime and example together
gcc -std=c99 -O2 -I src/runtime \
    examples/launch_saxpy.c src/runtime/bc_runtime.c \
    -ldl -lm -o launch_saxpy

# Compile a kernel and run it
./barracuda --amdgpu-bin -o test.hsaco tests/canonical.cu
./launch_saxpy test.hsaco

Requires Linux with ROCm installed. See examples/launch_saxpy.c for a complete example.

What Works

The following CUDA features compile to working GFX9/GFX10/GFX11/GFX12 machine code, NVIDIA PTX, and Tensix Metalium C++:

Core Language

__global__, __device__, __host__ function qualifiers
threadIdx, blockIdx, blockDim, gridDim builtins
Structs (named + anonymous inline), enums, typedefs, namespaces
Pointers, arrays, pointer arithmetic
All C control flow: if/else, for, while, do-while, switch/case, goto/label
Short-circuit && and ||
Ternary operator
Templates (basic instantiation)
Multiple return paths, continue, break

CUDA Features

__shared__ memory (allocated from LDS, properly tracked)
__syncthreads() → s_barrier
Atomic operations: atomicAdd, atomicSub, atomicMin, atomicMax, atomicExch, atomicCAS, atomicAnd, atomicOr, atomicXor
Warp intrinsics: __shfl_sync, __shfl_up_sync, __shfl_down_sync, __shfl_xor_sync
Warp votes: __ballot_sync, __any_sync, __all_sync
Vector types: float2, float3, float4, int2, int3, int4 with .x/.y/.z/.w access
Half precision: __half, __float2half(), __half2float(), __nv_bfloat16
__launch_bounds__ (parsed, propagated, enforces VGPR caps)
Cooperative groups: cooperative_groups::this_thread_block() with .sync(), .thread_rank(), .size()
Operator overloading
Math builtins: sqrtf, rsqrtf, expf, exp2f, logf, log2f, log10f, sinf, cosf, tanf, tanhf, powf, fabsf, floorf, ceilf, truncf, roundf, rintf, fmaxf, fminf, fmodf, copysignf
__constant__ memory, __device__ globals

Compiler Features

Full C preprocessor: #include, #define/#undef, function-like macros, #ifdef/#ifndef/#if/#elif/#else/#endif, #pragma, #error, -I/-D flags
Error recovery (reports multiple errors without hanging)
Multilingual error messages (--lang <file>) with language-neutral E-codes
Source location tracking in IR dumps
Struct pass-by-value

Example

__global__ void vector_add(float *c, float *a, float *b, int n)
{
    int idx = threadIdx.x + blockIdx.x * blockDim.x;
    if (idx < n)
        c[idx] = a[idx] + b[idx];
}

$ ./barracuda --amdgpu-bin vector_add.cu -o vector_add.hsaco
wrote vector_add.hsaco (528 bytes code, 1 kernels)

No LLVM required 😃

Validated on Hardware

BarraCUDA-compiled kernels have been tested and produce correct results on real silicon:

AMD MI300X (CDNA3, GFX942) — 8/8 test kernels passing. Monte Carlo neutron transport producing correct physics (k_eff = 0.995, matching reference).
AMD RDNA3 (GFX1100) — Full test suite passing via RDNA3 emulator CI.
NVIDIA RTX 4060 Ti — PTX backend, loaded via CUDA Driver API, JIT-compiled by NVIDIA driver. Monte Carlo neutron transport benchmark produces correct results with 3.8x speedup over single-thread CPU. No NVCC involved anywhere in the pipeline.
Tenstorrent Blackhole — Compiles to valid Metalium C++. Hardware validation pending dev kit access.

What Doesn't Work (Yet)

Being honest about limitations is important. Here's what's missing:

Parameter reassignment in __device__ functions (use local variables)
Textures and surfaces
Dynamic parallelism (device-side kernel launch)
Multiple translation units
Host code generation (only device code is compiled)

None of these are architectural blockers. They're all "haven't got round to it yet" items.

Test Suite

14 test files, 35+ kernels, ~1,700 BIR instructions, ~27,000 bytes of machine code:

vector_add.cu - The "hello world" of GPU computing
cuda_features.cu - Atomics, warp ops, barriers, gotos, switch, short-circuit
test_tier12.cu - Vectors, shared memory, operator overloading
notgpt.cu - AI-generated CUDA with extremely sarcastic comments (tiled SGEMM, reductions, histograms, prefix scan, stencils, half precision, cooperative groups, and the "kitchen sink" kernel)
stress.cu - N-body simulation, nested control flow, bit manipulation, struct pass-by-value, chained function calls
canonical.cu - Canonical patterns from NVIDIA samples adapted for the parser
test_errors.cu - Deliberate syntax errors to verify error recovery
test_launch_bounds.cu - __launch_bounds__ parsing and VGPR cap enforcement
test_coop_groups.cu - Cooperative groups lowering
mymathhomework.cu - Trig identities, exponential growth, Newton-Raphson, log laws, hyperbolic functions, floor/ceil/round, power rule, clamping
Plus preprocessor tests, template tests, unsigned integer tests

Roadmap

Near Term: Hardening

Fix the known gaps: integer literal suffixes, const, parameter reassignment. These are all small parser/lowerer changes. The goal is to compile real-world .cu files without modifications.

Medium Term: Optimisation

The generated code works but isn't winning any benchmarks. Done so far: instruction scheduling, constant folding, dead code elimination, divergence-aware SSA register allocation. Priorities:

Loop-invariant code motion
Occupancy tuning based on register pressure

Long Term: More Architectures

The IR (BIR) is target-independent. The backend is cleanly separated. Adding a new target means writing a new isel + emit pair.

NVIDIA PTX - Done. Compiles CUDA to PTX, validated on RTX 4060 Ti. --nvidia-ptx
Tenstorrent Tensix - Done. Compiles CUDA to TT-Metalium C++ for Blackhole. --tensix
Intel Arc - Xe architecture. Would give BarraCUDA coverage across all four major GPU vendors.
RISC-V Vector Extension - For when GPUs are too mainstream and you want to run CUDA on a softcore.

Contributing

Issues and PRs in any language are welcome — just include an English translation alongside. See CONTRIBUTING.md for the full guide on style, naming, and where to help.

The HLASM-style short identifiers (ra_gc, mk_hash, enc_vop3) are culturally neutral by accident, there's nothing English about a 5-character label. If you've found a bug or have an idea, write it up in whatever language you think in.

Changelog

2026-03-18 — NVIDIA PTX backend (--nvidia-ptx). Compiles CUDA to PTX text, loaded via CUDA Driver API and JIT-compiled by the NVIDIA driver. Validated on RTX 4060 Ti running a Monte Carlo neutron transport benchmark with correct physics results. No NVCC required. Also: anonymous struct/union support in parser, sema, and lowerer (struct { float f; int i; } cvt; pattern).

2026-03-14 — Divergence-aware SSA register allocator (--ssa-ra). Eliminates all 186 VGPR spills on a 654-line Monte Carlo transport kernel — scratch traffic drops 78%, total instructions drop 28%. Exploits the 64:1 cost asymmetry between divergent and uniform VGPR spills on Wave64 hardware: uniform values spill via v_readfirstlane at 4 bytes each, divergent values stay in registers where they belong. Based on the divergence analysis of Sampaio et al. (2013). ~1,300 lines of C99, all static memory, no malloc.

2026-03-09 — Post-isel verification pass (bc_vfy). The encoder used to trust isel to produce valid machine instructions. It shouldn't have. bc_vfy runs twice (post-isel, post-RA) and catches 5 classes of encoding violation before the binary leaves the compiler. Its first run immediately found 7 isel bugs across GFX10 and GFX942 — every one a silent miscompile that would fault on hardware with "Reason: Unknown." Fixed them all. Also: bc_abend runtime crash diagnostics, because if IBM could do post-mortem dumps in 1964, we can do it for GPUs in 2026.

2026-03-08 — Error localisation infrastructure. Every diagnostic now has a language-neutral ID (E001–E111). External translation files via --lang <file>. English reference at lang/en.txt, te reo Maori at lang/mi.txt. Unified error structs. Lowering errors now displayed.

2026-03-05 — CDNA 3 additions: GFX942 backend hardening, MFMA, Wave64 divergence, tinygrad compat. 8/8 tests passing on MI300X (PR#56).

2026-03-05 — Instruction scheduling (PR#52).

2026-03-03 — CDNA 2 support (--gfx90a, MI250). Tinygrad compatibility.

2026-02-28 — Tenstorrent Tensix backend (--tensix). Compiles CUDA to TT-Metalium C++ for Blackhole. Constant folding (PR#51). Dead code elimination (PR#48).

2026-02-25 — HSA runtime launcher (PR#40). RDNA 2 support (--gfx1030, PR#38). Test suite (PR#41).

2026-02-20 — RDNA 4 support (--gfx1200, PR#32).

2026-02-16 — Initial release. CUDA compiler targeting AMD RDNA 3 (gfx1100).

Contact

Found a bug? Want to discuss the finer points of AMDGPU instruction encoding? Need someone to commiserate with about the state of GPU computing?

zanehambly@gmail.com

Open an issue if there's anything you want to discuss. Or don't. I'm not your mum.

Based in New Zealand, where it's already tomorrow and the GPUs are just as confused as everywhere else.

License

Apache 2.0. Do whatever you want. If this compiler somehow ends up in production, I'd love to hear about it, mostly so I can update my LinkedIn with something more interesting than wrote a CUDA compiler for fun.

Acknowledgements

Fernando Magno Quintão Pereira and the Compilers Lab at UFMG (Universidade Federal de Minas Gerais). Fernando reached out after seeing the project, pointed me to the divergence analysis papers, and offered guidance. The SSA register allocator exists because of that conversation.
The academic community — Cooper, Harvey & Kennedy for dominators; Braun & Hack for SSA spilling; Sampaio, Souza, Collange & Pereira for divergence analysis. I'm just a hobbyist who reads papers and writes C. The actual hard work was done by the researchers.
Steven Muchnick for Advanced Compiler Design and Implementation. If this compiler does anything right, that book is why.
Low Level for the Zero to Hero C course and the YouTube channel. That's where I learnt C.
Abe Kornelis for being an amazing teacher. His work on the z390 Portable Mainframe Assembler project is well worth your time.
To the people who've sent messages of kindness and critique, thank you from a forever student and a happy hobbyist.
My Granny, Grandad, Nana and Baka. Love you x

He aha te mea nui o te ao. He tāngata, he tāngata, he tāngata.

What is the most important thing in the world? It is people, it is people, it is people.

reactos/reactos

A free Windows-compatible Operating System

Quick Links

Website • Official chat • Wiki • Forum • Community Discord • JIRA Bug Tracker • ReactOS Git mirror • Testman

What is ReactOS?

ReactOS™ is an Open Source effort to develop a quality operating system that is compatible with applications and drivers written for the Microsoft® Windows™ NT family of operating systems (NT4, 2000, XP, 2003, Vista, 7).

The ReactOS project, although currently focused on Windows Server 2003 compatibility, is always keeping an eye toward compatibility with Windows Vista and future Windows NT releases.

The code of ReactOS is licensed under GNU GPL 2.0.

Product quality warning

ReactOS is currently an Alpha quality operating system. This means that ReactOS is under heavy development and you have to be ready to encounter some problems. Different things may not work well and it can corrupt the data present on your hard disk. It is HIGHLY recommended to test ReactOS on a virtual machine or on a computer with no sensitive or critical data!

Building

To build the system it is strongly advised to use the ReactOS Build Environment (RosBE). Up-to-date versions for Windows and for Unix/GNU-Linux are available from our download page at: "Build Environment".

Alternatively one can use Microsoft Visual C++ (MSVC) version 2019+. Building with MSVC is covered here: "Visual Studio or Microsoft Visual C++".

See "Building ReactOS" article for more details.

Binaries

To build ReactOS you must run the configure script in the directory you want to have your build files. Choose configure.cmd or configure.sh depending on your system. Then run ninja <modulename> to build a module you want or just ninja to build all modules.

Bootable images

To build a bootable CD image run ninja bootcd from the build directory. This will create a CD image with a filename bootcd.iso.

You can always download fresh binary builds of bootable images from the "Daily builds" page.

Installing

By default, ReactOS currently can only be installed on a machine that has a FAT16 or FAT32 partition as the active (bootable) partition. The partition on which ReactOS is to be installed (which may or may not be the bootable partition) must also be formatted as FAT16 or FAT32. ReactOS Setup can format the partitions if needed.

Starting with 0.4.10, ReactOS can be installed using the BtrFS file system. But consider this as an experimental feature and thus regressions not triggered on FAT setup may be observed.

To install ReactOS from the bootable CD distribution, extract the archive contents. Then burn the CD image, boot from it, and follow the instructions.

See "Installing ReactOS" Wiki page or INSTALL for more details.

Testing

If you discover a bug in ReactOS search on JIRA first - it might be reported already. If not report the bug providing logs and as much information as possible.

See "File Bugs" for a guide.

NOTE: The bug tracker is not for discussions. Please use our official chat or our forum.

Contributing

We are always looking for developers! Check how to contribute if you are willing to participate.

Legal notice: If you have seen proprietary Microsoft Windows source code (including but not limited to the leaked Windows NT 3.5, NT 4, 2000 source code and the Windows Research Kernel), your contribution won't be accepted because of potential copyright violation.

Try out cloud-based ReactOS development using Gitpod and Docker:

You can also support ReactOS by donating! We rely on our backers to maintain our servers and accelerate development by hiring full-time devs.

More information

ReactOS is a Free and Open Source operating system based on the Windows architecture, providing support for existing applications and drivers, and an alternative to the current dominant consumer operating system.

It is not another wrapper built on Linux, like WINE. It does not attempt or plan to compete with WINE; in fact, the user-mode part of ReactOS is almost entirely WINE-based and our two teams have cooperated closely in the past.

ReactOS is also not "yet another OS". It does not attempt to be a third player like any other alternative OS out there. People are not meant to uninstall Linux and use ReactOS instead; ReactOS is a replacement for Windows users who want a Windows replacement that behaves just like Windows.

More information is available at: reactos.org.

Also see the media/doc subdirectory for some sparse notes.

Who is responsible

Active devs are listed as members of GitHub organization. See also the CREDITS file for others.

Code mirrors

The main development is done on GitHub. We have an alternative mirror in case GitHub is down.

There is also an obsolete SVN archive repository that is kept for historical purposes.

pjsip/pjproject

PJSIP project

PJSIP

PJSIP is a free and open source multimedia communication library written in C with high level API in C, C++, Java, C#, and Python languages. It implements standard based protocols such as SIP, SDP, RTP, STUN, TURN, and ICE. It combines signaling protocol (SIP) with rich multimedia framework and NAT traversal functionality into high level API that is portable and suitable for almost any type of systems ranging from desktops, embedded systems, to mobile handsets.

Getting PJSIP

Main repository: https://github.com/pjsip/pjproject
Releases: https://github.com/pjsip/pjproject/releases

Documentation

Main documentation site: https://docs.pjsip.org

Table of contents:

Overview
Getting started
PJSUA2 - High level API guide
Specific guides
API reference
- PJSUA2 - high level API (Java/C#/Python/C++/swig)
- PJSUA-LIB - high level API (C)
- PJSIP - SIP stack
- PJMEDIA - media framework
- PJNATH - NAT traversal helper
- PJLIB-UTIL - utilities
- PJLIB - portable library

GitHub C Daily Trending

lvgl/lvgl

Light and Versatile Graphics Library

Table of Contents

📒 Overview

💡 Features

📦️ Platform Support

🚀 LVGL Pro Editor

🤝 Commercial Services

🧑‍💻 Integrating LVGL

🤖 Examples

Hello World Button with an Event

Styled Slider with Data-binding

Checkboxes in a Layout

🌟 Contributing

pbatard/rufus

Rufus: The Reliable USB Formatting Utility

Features

Compilation

Visual Studio

Additional information

Enhancements/Bugs

espressif/esp-idf

Espressif IoT Development Framework

ESP-IDF Release Support Schedule

ESP-IDF Release and SoC Compatibility

Developing With ESP-IDF

Setting Up ESP-IDF

Non-GitHub forks

Finding a Project

Quick Reference

Setup Build Environment

Configuring the Project

Compiling the Project

Flashing the Project

Viewing Serial Output

Compiling & Flashing Only the App

Erasing Flash

Resources

lightpanda-io/browser

Lightpanda Browser

Benchmarks

Quick start

Install

Dump a URL

Start a CDP server

Native MCP and skill

Telemetry

Status

Build from sources

Prerequisites

Build and run

Embed v8 snapshot

Test

Unit Tests

End to end tests

Web Platform Tests

Configure WPT HTTP server

Run WPT test suite

Contributing

Why Lightpanda?

Javascript execution is mandatory for the modern web

Chrome is not the right tool

Lightpanda is built for performance

qmk/qmk_firmware

Quantum Mechanical Keyboard Firmware

Documentation

Supported Keyboards

Maintainers

Official Website

timescale/timescaledb

TimescaleDB is a PostgreSQL extension for high-performance real-time analytics on time-series and event data

Quick Start with TimescaleDB

What You'll Learn

Prerequisites

Step 1: Start TimescaleDB

Option 1: One-line install (Recommended)

Option 2: Manual Docker command also used for Windows

Step 2: Connect to TimescaleDB

Step 3: Create Your First Hypertable