GitHub Kotlin Monthly Trending

2dust/v2rayNG

A V2Ray client for Android, support Xray core and v2fly core

v2rayNG

A V2Ray client for Android, support Xray core and v2fly core

Telegram Channel

github_2dust

Usage

Geoip and Geosite

geoip.dat and geosite.dat files are in Android/data/com.v2ray.ang/files/assets (path may differ on some Android device)
download feature will get enhanced version in this repo (Note it need a working proxy)
latest official domain list and ip list can be imported manually
possible to use third party dat file in the same folder, like h2y

Development guide

Android project under V2rayNG folder can be compiled directly in Android Studio, or using Gradle wrapper. But the v2ray core inside the aar is (probably) outdated.
The aar can be compiled from the Golang project AndroidLibV2rayLite or AndroidLibXrayLite. For a quick start, read guide for Go Mobile and Makefiles for Go Developers

v2rayNG can run on Android Emulators. For WSA, VPN permission need to be granted via appops set [package name] ACTIVATE_VPN allow

bannedbook/fanqiang

翻墙-科学上网

翻墙-科学上网、翻墙工具、翻墙教程项目库

Windows V2ray/SS/SSR 翻墙教程

iPhone/iPad/iOS V2ray/SS 翻墙APP教程

Android 安卓翻墙APP教程

Mac翻墙软件教程

路由器翻墙教程

Linux翻墙教程

游戏机翻墙教程

ChromeGo - Chrome一键翻墙包

一个集成Goflyway、v2ray、Daze、SSR、Brook、Lightsocks、trojan、蓝灯、psiphon等N多翻墙工具的电脑翻墙包（推荐按前面所列顺序依次尝试），所有工具全部内置免费服务器，长期更新。由于国内网络环境复杂、地区不同，网络运营商不同，封锁情况都不同，所以使用效果会有差别，有的地区几乎所有的软件都能使用，有的只能用几款，因此具体哪款软件适合你的网络环境，需要你自己来尝试。

推荐：

下载Chrome一键翻墙包

Chrome一键翻墙包

使用Chrome一键翻墙包

请首先自行安装Google Chrome 浏览器，然后下载Chrome一键翻墙包，本软件会自动调用Google Chrome 浏览器翻墙。下载后，解压出来，请不要解压到含有中文或空格的目录路径，请不要不解压就直接从压缩包里运行！不解压会出错！下载后，请认真阅读里面的使用帮助说明，然后 0.xx-10.xx翻墙可依次尝试。自动回复最新翻墙信息网址：freeman105@gmail.com，邮箱不解答问题,如需反馈交流，请点我或加入翻墙电报群: https://t.me/fqchat

请随意分发，勿做商业使用。

koiverse/ArchiveTune

The Cutest Material 3 Expressive Music Player With Support Local File and Youtube Music for Android.

ArchiveTune

Redefining the YouTube Music Experience on Android.
It’s high-performance, privacy-focused, and packed with features for people who really care about their experience.

Official Website • Features • Privacy • Download • Screenshots • Support

ArchiveTune isn’t just another generic YouTube Music wrapper. It’s a fully custom-built player made from the ground up, because we think your music should stay private, look clean, and work exactly the way you expect. If you care about sound quality and want something that actually feels good to use, this is it.

Important

Geographic Availability: If YouTube Music is not supported in your region, a VPN or proxy set to a supported region is required for initial data fetching.

📸 Showcase

✨ Features

Playback Ad-free playback with background listening Your playlists, liked songs, and subscriptions appear after sign-in Support local file and local song playback Fast startup and lightweight performance Built for a private, uninterrupted listening experience	Audio EBU R128 loudness normalization Tempo, pitch, and playback speed controls Crossfade between tracks System equalizer and spatial audio integration
Lyrics & Discovery Live synced lyrics Lyrics translation and romanization Music recognition for songs around you Listening statistics whenever you want them	Sync & Social YouTube Music account integration Last.fm scrobbling ListenBrainz history sync Discord rich presence support
Interface Material 3 design language Album-art powered dynamic colors Responsive layouts for different screen sizes Clean browsing, player, artist, album, and lyrics views	Customization Deep playback and interface settings Gesture customization Animation and layout tuning Flexible controls to shape the app around your workflow

📥 Download Now

Stable Release

Obtainium	IzzyOnDroid

GitHub

OpenAPK	Unclouded

Nightly Build

GitHub Actions

Warning

Notes: The trusted download source is listed above; we are not responsible for any risks you may encounter from downloading from other sources.

❓ Need Help or Have Questions?

Join Our Telegram Channels or Discord Servers for Support and Discussion.

🌍 Globalization

ArchiveTune belongs to everyone. Help us localize the experience for your region.

✨ Project Contributors

🛠️ Development & Engineering

Interested in building the project or contributing? ArchiveTune is built on a high-performance Kotlin stack. Read the Build & Contribution Guide →

⭐ Support the Project

ArchiveTune is free and open-source. If it brings you joy, consider supporting its development!

Tribe

🤝 Acknowledgments

We stand on the shoulders of open-source giants:

Metrolist by Mostafa Alagamy For Base framework.
Kizzy by dead8309 For Discord Integration.
SimpMusic by maxrave-dev For Lyrics API Provider.
BetterLyrics For word-by-word Lyrics API Provider & Artwork Provider.
Material Color Utilities
Read You and Seal for Ui Components.
The global community of translators and beta testers.

⚖️ Legal Disclaimer

ArchiveTune is an independent third-party client.

Not affiliated with Google LLC or YouTube.
Does not bypass YouTube's technical protections.
Users are encouraged to support artists by purchasing music via official channels.

If ArchiveTune elevated your music experience, please consider giving us a ⭐

amir1376/ab-download-manager

A Download Manager that speeds up your downloads

AB Download Manager

Description

AB Download Manager is a desktop app that helps you manage and organize your downloads more efficiently than ever before.

Features

⚡️ Faster Download Speed
⏰ Queues and Schedulers
🌐 Browser Extensions
💻 Multiplatform (Android / Windows / Linux / Mac)
🌙 Multiple Themes (Dark/Light/Black and more) with modern UI
❤️ Free and Open Source

Please visit Project Website for more info.

Installation

Download and Install the App

Installation script (Linux)

bash <(curl -fsSL https://raw.githubusercontent.com/amir1376/ab-download-manager/master/scripts/install.sh)

Winget or Scoop (for Windows)

winget:

winget install amir1376.ABDownloadManager

scoop:

scoop install extras/abdownloadmanager

Homebrew (for macOS & Linux)

brew tap amir1376/tap && brew install --cask ab-download-manager

⚠️ Warning: This software is NOT on Google Play or other app stores unless listed here. Any version claiming to be or related to this project should be considered SCAM and UNSAFE.

For alternative installation methods, uninstallation instructions, and more details, please refer to the wiki page.

Browser Extensions

You can download the browser extension to integrate the app with your browser.

Screenshots

Project Status & Feedback

Please keep in mind that this project is in the beginning of its journey. Lots of features are on the way!

But, in the meantime you may face Bugs or Problems. If you do, please report them to me via the Community chat or through GitHub Issues, and I'll do my best to fix them ASAP.

Community

You can join our Telegram Group to:

Report problems
Suggest features
Get help with the app

Repositories And Source Code

There are multiple repositories related to the AB Download Manager project:

Repository	Description
Main Application (You are here)	Contains the Application that runs on your device
Browser Integration	Contains the Browser Extension to be installed on your browser
Website	Contains the AB Download Manager website

I've spent a lot of time to create this project.

If you like my work, please consider giving it a ⭐ — thanks! ❤️

Bug Report

If you notice any bugs in the source code, please report them via the GitHub Issues section.

Build From Source

To compile and test the desktop app on your local machine, follow these steps:

Clone the project.
Download and extract the JBR, and make it available by either:
- Adding it to your PATH, or
- Setting the JAVA_HOME environment variable to its installation path.
Navigate to the project directory, open your terminal and execute the following command:
```
./gradlew createReleaseFolderForCi
```
The output will be available at:
```
<project_dir>/build/ci-release
```

Note. This project is compiled and published by GitHub actions here, so if you faced any problem you can check that too.

Translations

If you’d like to help translate AB Download Manager into another language, or improve existing translations, you can do so on Crowdin. Here’s how:

Visit the project in Crowdin
Please DO NOT submit translations via pull requests.
If you want to add a new language, please see this.

Contribution

If you want to contribute to this project, please read Contributing Guide first.

Support the Project

If you'd like to support the project, you can find details on how to donate in the DONATE.md file.

ZalithLauncher/ZalithLauncher2

A Minecraft: Java Edition Launcher for Android

Zalith Launcher 2

简体中文 | 繁體中文

Important

This project is completely separate from ZalithLauncher.

Zalith Launcher 2 is a newly designed launcher for Android devices tailored for Minecraft: Java Edition. The project uses PojavLauncher as its core launching engine and features a modern UI built with Jetpack Compose and Material Design 3.
We are currently building our official website zalithlauncher.cn
Additionally, we are aware that a third-party website has been set up using the name “Zalith Launcher”, appearing to be official. Please note: this site was not created by us. It exploits the name to display ads for profit. We do not participate in, endorse, or trust such content.
Please stay vigilant and protect your personal privacy!

Discord Server Shutdown Announcement

🌐 Language and Translation Support

We are using the Weblate platform to translate Zalith Launcher 2. You're welcome to join our Weblate project and contribute to the translations!
Thank you to every language contributor for helping make Zalith Launcher 2 more multilingual and global!

📦 Build Instructions (For Developers)

The following section is for developers who wish to contribute or build the project locally.

Requirements

Android Studio Bumblebee or newer
Android SDK:
- Minimum API level: 26
- Target API level: 35
JDK 11

Build Steps

git clone git@github.com:ZalithLauncher/ZalithLauncher2.git
# Open the project in Android Studio and build

📜 License

This project is licensed under the GPL-3.0 license.

Additional Terms (Pursuant to Section 7 of the GPLv3 License)

When distributing a modified version of this program, you must reasonably modify the program's name or version number to distinguish it from the original version. (According to GPLv3, 7(c))
- Modified versions must not include the original program name "ZalithLauncher" or its abbreviation "ZL" in their name, nor use any name that is similar enough to cause confusion with the official name.
- All modified versions must clearly indicate that they are “Unofficial Modified Versions” on the program’s startup screen or main interface.
- The application name of the program can be modified in gradle.properties.
You must not remove the copyright notices displayed by the program. (According to GPLv3, 7(b))

Open Source Libraries and Licenses

This software uses the following open source libraries:

Library	Copyright	License	Official Link
androidx-constraintlayout-compose	Copyright © The Android Open Source Project	Apache 2.0	Link
androidx-material-icons-core	Copyright © The Android Open Source Project	Apache 2.0	Link
androidx-material-icons-extended	Copyright © The Android Open Source Project	Apache 2.0	Link
ANGLE	Copyright 2018 The ANGLE Project Authors	BSD 3-Clause License	Link
Apache Commons Codec	-	Apache 2.0	Link
Apache Commons Compress	-	Apache 2.0	Link
Apache Commons IO	-	Apache 2.0	Link
ByteHook	Copyright © 2020-2024 ByteDance, Inc.	MIT License	Link
Coil Compose	Copyright © 2025 Coil Contributors	Apache 2.0	Link
Coil Gifs	Copyright © 2025 Coil Contributors	Apache 2.0	Link
Coil SVG	Copyright © 2025 Coil Contributors	Apache 2.0	Link
Fishnet	Copyright © 2025 Kyant	Apache 2.0	Link
gl4es_extra_extra	Copyright © 2016-2018 Sebastien Chevalier; Copyright (c) 2013-2016 Ryan Hileman	MIT License	Link
Gson	Copyright © 2008 Google Inc.	Apache 2.0	Link
kotlinx.coroutines	Copyright © 2000-2020 JetBrains s.r.o.	Apache 2.0	Link
ktor-client-cio	Copyright © 2000-2023 JetBrains s.r.o.	Apache 2.0	Link
ktor-client-content-negotiation	Copyright © 2000-2023 JetBrains s.r.o.	Apache 2.0	Link
ktor-client-core	Copyright © 2000-2023 JetBrains s.r.o.	Apache 2.0	Link
ktor-http	Copyright © 2000-2023 JetBrains s.r.o.	Apache 2.0	Link
ktor-serialization-kotlinx-json	Copyright © 2000-2023 JetBrains s.r.o.	Apache 2.0	Link
LWJGL - Lightweight Java Game Library	Copyright © 2012-present Lightweight Java Game Library All rights reserved.	BSD 3-Clause License	Link
material-color-utilities	Copyright 2021 Google LLC	Apache 2.0	Link
Maven Artifact	Copyright © The Apache Software Foundation	Apache 2.0	Link
Media3	Copyright © The Android Open Source Project	Apache 2.0	Link
Mesa	Copyright © The Mesa Authors	MIT License	Link
MMKV	Copyright © 2018 THL A29 Limited, a Tencent company.	BSD 3-Clause License	Link
Navigation 3	Copyright © The Android Open Source Project	Apache 2.0	Link
NBT	Copyright © 2016 - 2020 Querz	MIT License	Link
NG-GL4ES	Copyright © 2016-2018 Sebastien Chevalier; Copyright © 2013-2016 Ryan Hileman; Copyright (c) 2025-2026 BZLZHH	MIT License	Link
OkHttp	Copyright © 2019 Square, Inc.	Apache 2.0	Link
Okio	Copyright © 2013 Square, Inc.	Apache 2.0	Link
Process Phoenix	Copyright © 2015 Jake Wharton	Apache 2.0	Link
proxy-client-android	-	LGPL-3.0 License	Link
Reorderable	Copyright © 2023 Calvin Liang	Apache 2.0	Link
skinview3d	Copyright © 2014-2018 Kent Rasmussen; Copyright © 2017-2022 Haowei Wen, Sean Boult and contributors	MIT License	Link
sora-editor	Copyright © 1991, 1999 Free Software Foundation, Inc.	LGPL-2.1 License	Link
StringFog	Copyright © 2016-2023, Megatron King	Apache 2.0	Link
XZ for Java	Copyright © The XZ for Java authors and contributors	0BSD License	Link

embabel/embabel-agent

Agent framework for the JVM. Pronounced Em-BAY-bel /ɛmˈbeɪbəl/

Embabel Agent Framework

Embabel (Em-BAY-bel) is a framework for authoring agentic flows on the JVM that seamlessly mix LLM-prompted interactions with code and domain models. Supports intelligent path finding towards goals. Written in Kotlin but offers a natural usage model from Java. From the creator of Spring.

Key Concepts

Models agentic flows in terms of:

Actions: Steps an agent takes
Goals: What an agent is trying to achieve
Conditions: Conditions to assess before executing an action or determining that a goal has been achieved. Conditions are reassessed after each action is executed.
Domain model: Objects underpinning the flow and informing Actions, Goals and Conditions.
Plan: A sequence of actions to achieve a goal. Plans are dynamically formulated by the system, not the programmer. The system replans after the completion of each action, allowing it to adapt to new information as well as observe the effects of the previous action. This is effectively an OODA loop.

Application developers don't usually have to deal with these concepts directly, as most conditions result from data flow defined in code, allowing the system to infer pre and post conditions.

These concepts underpin these differentiators versus other agent frameworks:

Sophisticated planning. Goes beyond a finite state machine or sequential execution with nesting by introducing a true planning step, using a non-LLM AI algorithm. This enables the system to perform tasks it wasn’t programmed to do by combining known steps in a novel order, as well as make decisions about parallelization and other runtime behavior.
Superior extensibility and reuse: Because of dynamic planning, adding more domain objects, actions, goals and conditions can extend the capability of the system, without editing FSM definitions or existing code.
Strong typing and the benefits of object orientation: Actions, goals and conditions are informed by a domain model, which can include behavior. Everything is strongly typed and prompts and manually authored code interact cleanly. No more magic maps. Enjoy full refactoring support.

Other benefits:

Platform abstraction: Clean separation between programming model and platform internals allows running locally while potentially offering higher QoS in production without changing application code.
Designed for LLM mixing: It is easy to build applications that mix LLMs, ensuring the most cost-effective yet capable solution. This enables the system to leverage the strengths of different models for different tasks. In particular, it facilitates the use of local models for point tasks. This can be important for cost and privacy.
Built on Spring and the JVM, making it easy to access existing enterprise functionality and capabilities. For example:
- Spring can inject and manage agents, including using Spring AOP to decorate functions.
- Robust persistence and transaction management solutions are available.
Designed for testability from the ground up. Both unit testing and agent end to end testing are easy.

Flows can be authored in one of two ways:

An annotation-based model similar to Spring MVC, with types annotated with the Spring stereotype @Agent, using @Goal, @Condition and @Action methods.
Idiomatic Kotlin DSL with agent { and action { blocks.

Either way, flows are backed by a domain model of objects that can have rich behavior.

We are working toward allowing natural language actions and goals to be deployed.

The planning step is pluggable.

The default planning approach is Goal Oriented Action Planning. GOAP is a popular AI planning algorithm used in gaming. It allows for dynamic decision-making and action selection based on the current state of the world and the goals of the agent.

Goals, actions and plans are independent of GOAP. Embabel also supports Utility AI out of the box, which can run the same actions but chooses actions based on (potentially dynamic) utility scores rather than strict preconditions and postconditions. This is valuable for exploration and open-ended tasks, when we do not need to achieve a specific goal but want to maximize overall utility.

The framework executes via an AgentPlatform implementation.

An agent platform supports the following modes of execution:

Focused, where user code requests particular functionality: User code calls a method to run a particular agent, passing in input. This is ideal for code-driven flows such as a flow invoked in response to an incoming event.
Closed, where user intent (or another incoming event) is classified to choose an agent. The platform tries to find a suitable agent among all the agents it knows about. Agent choice is dynamic, but only actions defined within the particular agent will run.
Open, where the user's intent is assessed and the platform uses all its resources to try to achieve it. The platform tries to find a suitable goal among all the goals it knows about and builds a custom agent to achieve it from the start state, including relevant actions and conditions. The platform will not proceed if it is unconvinced as to the applicability of any goal. The GoalChoiceApprover interface provides developers a way to limit goal choice further.

Open mode is the most powerful, but least deterministic.

In open mode, the platform is capable of finding novel paths that were not envisioned by developers, and even combining functionality from multiple providers.

Even in open mode, the platform will only perform individual steps that have been specified. (Of course, steps may themselves be LLM transforms, in which case the prompts are controlled by user code but the results are still non-deterministic.)

Possible future modes:

Evolving mode: Where the platform can work with multiple goals in the same process and modify a running process to add further goals and agents. For example, an action can realize that it has become important to achieve additional goals.

Embabel agent systems will also support federation, both with other Embabel systems (allowing planning to incorporate remote actions and goals) and third party agent frameworks.

Quick Start

Get an agent running in under 5 minutes.

Create your own agent repo from our Java or Kotlin GitHub template by clicking the "Use this template" button.

You'll have an agent running in under a minute if you already have an OPENAI_API_KEY and have Maven installed.

📚 For examples and tutorials, see the Embabel Agent Examples Repository

🚗 For a sophisticated, realistic example application, see the Tripper travel planner agent

AI-generated travel itinerary with detailed recommendations

Map link included in output

Why Is Embabel Needed?

TL;DR Because the evolution of agent frameworks is early and there's a lot of room for improvement; because an agent framework on the JVM will deliver great business value.

Why do we need an agent framework at all? We can write code without higher level abstractions, directly invoking LLMs and controlling flow directly in code. However, a higher level agent framework offers compelling benefits. For example:
- Breaking up LLM interactions, making them simpler and more focused. This maximizes reuse and minimizes cost and errors. It often allows us to use cheaper models for point interactions.
- Facilitating both unit and integration testing, which remain as important with agentic systems as with any other software systems.
- Increasing composability where subflows and individual actions can be reused
- Making applications more manageable and robust, enabling a workflow manager to control their execution and retry operations while maintaining previous state
- Enhancing safety through the ability to apply guardrails in many places
Why do we need an agent framework for the JVM when solutions exist in Python?: While agent frameworks initially appeared predominantly Python, it's early and there's plenty of room for novel and superior approaches. The key adjacency is not the LLM--which is a simple HTTP call away--but existing code and infrastructure assets that are more valuable on the JVM than in Python.
Why not use just Spring AI? Spring AI is great. We build on it, and embrace the Spring component model. However, we believe that most applications should work with higher level APIs. An analogy: Spring AI exists at the level of the Servlet API, while Embabel is more like Spring MVC. Complex requirements are much easier to express and test in Embabel than with direct use of Spring AI.
Why not attempt to contribute this project to Spring? This project requires different governance from Spring, where most projects exist in stable environments and dependability and stability outweighs rapid innovation. Second, the concepts are not JVM-specific. We hope that Embabel will become the leading agent framework across platforms. While the Spring brand is valuable in Java, it is not in TypeScript or Python.

Show Me The Code

In Java or Kotlin, agent implementation code is intuitive and easy to test.

Java


@Agent(description = "Find news based on a person's star sign")
public class StarNewsFinder {

    private final HoroscopeService horoscopeService;
    private final int storyCount;

    // Services are injected by Spring
    public StarNewsFinder(
            HoroscopeService horoscopeService,
            @Value("${star-news-finder.story.count:5}") int storyCount) {
        this.horoscopeService = horoscopeService;
        this.storyCount = storyCount;
    }

    @Action
    public StarPerson extractStarPerson(UserInput userInput, Ai ai) {
        return ai
                .withLlm(OpenAiModels.GPT_41)
                .createObjectIfPossible(
                        """
                                Create a person from this user input, extracting their name and star sign:
                                %s""".formatted(userInput.getContent()),
                        StarPerson.class
                );
    }

    @Action
    public Horoscope retrieveHoroscope(StarPerson starPerson) {
        return new Horoscope(horoscopeService.dailyHoroscope(starPerson.sign()));
    }

    // toolGroups specifies tools that are required for this action to run
    @Action(toolGroups = {CoreToolGroups.WEB})
    public RelevantNewsStories findNewsStories(
            StarPerson person,
            Horoscope horoscope,
            Ai ai) {
        var prompt = """
                %s is an astrology believer with the sign %s.
                Their horoscope for today is:
                    <horoscope>%s</horoscope>
                Given this, use web tools and generate search queries
                to find %d relevant news stories summarize them in a few sentences.
                Include the URL for each story.
                Do not look for another horoscope reading or return results directly about astrology;
                find stories relevant to the reading above.
                
                For example:
                - If the horoscope says that they may
                want to work on relationships, you could find news stories about
                novel gifts
                - If the horoscope says that they may want to work on their career,
                find news stories about training courses.""".formatted(
                person.name(), person.sign(), horoscope.summary(), storyCount);
        return ai
                .withDefaultLlm()
                .createObject(prompt, RelevantNewsStories.class);
    }

    // The @AchievesGoal annotation indicates that completing this action
    // achieves the given goal, so the agent can be complete
    @AchievesGoal(
            description = "Write an amusing writeup for the target person based on their horoscope and current news stories",
            export = @Export(
                    remote = true,
                    name = "starNewsWriteupJava",
                    startingInputTypes = {StarPerson.class, UserInput.class})
    )
    @Action
    public Writeup writeup(
            StarPerson person,
            RelevantNewsStories relevantNewsStories,
            Horoscope horoscope,
            Ai ai) {
        var llm = LlmOptions
                .withModel(OpenAiModels.GPT_41_MINI)
                // High temperature for creativity
                .withTemperature(0.9);

        var newsItems = relevantNewsStories.getItems().stream()
                .map(item -> "- " + item.getUrl() + ": " + item.getSummary())
                .collect(Collectors.joining("\n"));

        var prompt = """
                Take the following news stories and write up something
                amusing for the target person.
                
                Begin by summarizing their horoscope in a concise, amusing way, then
                talk about the news. End with a surprising signoff.
                
                %s is an astrology believer with the sign %s.
                Their horoscope for today is:
                    <horoscope>%s</horoscope>
                Relevant news stories are:
                %s
                
                Format it as Markdown with links.""".formatted(
                person.name(), person.sign(), horoscope.summary(), newsItems);
        return ai
                .withLlm(llm)
                .createObject(prompt, Writeup.class);
    }
}

Kotlin

@Agent(description = "Find news based on a person's star sign")
class StarNewsFinder(
    // Services such as Horoscope are injected by Spring
    private val horoscopeService: HoroscopeService,
    // Potentially externalized by Spring
    @param:Value("\${star-news-finder.story.count:5}")
    private val storyCount: Int = 5,
) {

    @Action
    fun extractPerson(
        userInput: UserInput,
        ai: Ai
    ): StarPerson =
        // All prompts are typesafe
        ai.withDefaultLlm()
            .createObject("Create a person from this user input, extracting their name and star sign: $userInput")

    // This action doesn't use an LLM
    // Embabel makes it easy to mix LLM use with regular code
    @Action
    fun retrieveHoroscope(starPerson: StarPerson) =
        Horoscope(horoscopeService.dailyHoroscope(starPerson.sign))

    // This action uses tools
    // "toolGroups" specifies tools that are required for this action to run
    @Action(toolGroups = [ToolGroup.WEB])
    fun findNewsStories(
        person: StarPerson,
        horoscope: Horoscope,
        ai: Ai,
    ): RelevantNewsStories =
        ai.withDefaultLlm().createObject(
            """
            ${person.name} is an astrology believer with the sign ${person.sign}.
            Their horoscope for today is:
                <horoscope>${horoscope.summary}</horoscope>
            Given this, use web tools and generate search queries
            to find $storyCount relevant news stories summarize them in a few sentences.
            Include the URL for each story.
            Do not look for another horoscope reading or return results directly about astrology;
            find stories relevant to the reading above.

            For example:
            - If the horoscope says that they may
            want to work on relationships, you could find news stories about
            novel gifts
            - If the horoscope says that they may want to work on their career,
            find news stories about training courses.
        """.trimIndent()
        )

    // The @AchievesGoal annotation indicates that completing this action
    // achieves the given goal, so the agent run will be complete
    @AchievesGoal(
        description = "Write an amusing writeup for the target person based on their horoscope and current news stories",
    )
    @Action
    fun writeup(
        person: StarPerson,
        relevantNewsStories: RelevantNewsStories,
        horoscope: Horoscope,
        ai: Ai,
    ): Writeup =
        ai
            .withLlm(
                LlmOptions
                    .withModel(model)
                    .withTemperature(0.9)
            )
            .createObject(
                """
            Take the following news stories and write up something
            amusing for the target person.

            Begin by summarizing their horoscope in a concise, amusing way, then
            talk about the news. End with a surprising signoff.

            ${person.name} is an astrology believer with the sign ${person.sign}.
            Their horoscope for today is:
                <horoscope>${horoscope.summary}</horoscope>
            Relevant news stories are:
            ${relevantNewsStories.items.joinToString("\n") { "- ${it.url}: ${it.summary}" }}

            Format it as Markdown with links.
        """.trimIndent()
            )

}

The following domain classes ensure type safety:

Java


@JsonClassDescription("Person with astrology details")
@JsonDeserialize(as = StarPerson.class)
public record StarPerson(
        String name,
        @JsonPropertyDescription("Star sign") String sign
) implements Person {

    @JsonCreator
    public StarPerson(
            @JsonProperty("name") String name,
            @JsonProperty("sign") String sign
    ) {
        this.name = name;
        this.sign = sign;
    }

    @Override
    public String getName() {
        return name;
    }
}

public record Horoscope(String summary) {
}

@JsonClassDescription("Writeup relating to a person's horoscope and relevant news")
public record Writeup(String text) implements HasContent {

    @JsonCreator
    public Writeup(@JsonProperty("text") String text) {
        this.text = text;
    }

    @Override
    public String getContent() {
        return text;
    }
}

Kotlin

data class RelevantNewsStories(
    val items: List<NewsStory>
)

data class NewsStory(
    val url: String,

    val summary: String,
)

data class Subject(
    val name: String,
    val sign: String,
)

data class Horoscope(
    val summary: String,
)

data class FunnyWriteup(
    override val text: String,
) : HasContent

It's easy to unit test your agents to ensure that they correctly execute logic and pass the correct prompts and hyperparameters to LLMs. For example:

public class StarNewsFinderTest {

    @Test
    void writeupPromptMustContainKeyData() {
        HoroscopeService horoscopeService = mock(HoroscopeService.class);
        StarNewsFinder starNewsFinder = new StarNewsFinder(horoscopeService, 5);
        var context = new FakeOperationContext();
        context.expectResponse(new com.embabel.example.horoscope.Writeup("Gonna be a good day"));

        NewsStory cockatoos = new NewsStory(
                "https://fake.com.au",
                "Cockatoo behavior",
                "Cockatoos are eating cabbages"
        );

        NewsStory emus = new NewsStory(
                "https://morefake.com.au",
                "Emu movements",
                "Emus are massing"
        );

        StarPerson starPerson = new StarPerson("Lynda", "Scorpio");
        RelevantNewsStories relevantNewsStories = new RelevantNewsStories(Arrays.asList(cockatoos, emus));
        Horoscope horoscope = new Horoscope("This is a good day for you");

        starNewsFinder.writeup(starPerson, relevantNewsStories, horoscope, context);

        var prompt = context.getLlmInvocations().getFirst().getPrompt();
        var toolGroups = context.getLlmInvocations().getFirst().getInteraction().getToolGroups();


        assertTrue(prompt.contains(starPerson.getName()));
        assertTrue(prompt.contains(starPerson.sign()));
        assertTrue(prompt.contains(cockatoos.getSummary()));
        assertTrue(prompt.contains(emus.getSummary()));

        assertTrue(toolGroups.isEmpty(), "The LLM should not have been given any tool groups");
    }
}

Dog Food Policy

We believe that all aspects of software development and business can and should be greatly accelerated through the use of AI agents. The ultimate decision makers remain human, but they can and should be greatly augmented.

This project practices extreme dogfooding.

Our key principles:

We will use AI agents to help every aspect of the project: coding, documentation, community management, producing marketing copy etc. Any human performing a task should ask why it cannot be automated, and strive toward maximum automation.
Developers retain ultimate control. Developers are responsible for guiding agents toward the solution and iterating as necessary. A developer who commits or merges an agent contribution is responsible for ensuring that it meets the project coding standards, which are independent of the use of agents. For example, code must be human-readable.
We will favour open source agents built on the Embabel platform, and contribute improvements. While commercial agents may be more advanced in some areas, we believe that our platform is the best general solution for automation and by dogfooding we will improve it fastest. By open sourcing agents used on our open source projects, we will maximize benefit to the community.
We will prioritize agents that help accelerate our progress. Per the flight safety advice to fit your own mask before helping others, we will prioritize agents that help us accelerate our own progress. This will not only produce useful examples, but increase overall project velocity.

Developers must carefully read all code they commit and improve generated code if possible.

Coding agents are a special case. While the embabel-agent-code submodule offers support for project modification that is useful for project bootstrapping, coding agents are the most mature of commercial agents, and their vendors are heavily subsidising their users, making it economically irrational to insist on our own platform.

Getting Started

Get the bits
Set up your environment
Run the application

Getting the bits

Choose one of the following:

Clone the repository via git clone https://github.com/embabel/embabel-agent
Create a new Spring Boot project and add the necessary dependencies (see "Using Embabel Agent Framework in Your Project" below)

Environment variables

Environment variables are consistent with common usage, rather than Spring AI. For example, we prefer OPENAI_API_KEY to SPRING_AI_OPENAI_API_KEY.

Required:

OPENAI_API_KEY: For the OpenAI API

Optional:

ANTHROPIC_API_KEY: For the Anthropic API. Necessary for the coding agent.
MINIMAX_API_KEY: For the MiniMax API. Supports MiniMax-M2.7 and MiniMax-M2.7-highspeed models.

We strongly recommend providing both an OpenAI and Anthropic key, as some examples require both. And it's important to try to find the best LLM for a given task, rather than automatically choose a familiar provider.

Services

You will need a Docker Desktop version >4.43.2. Be sure to activate the following MCP tools from the catalog:

Brave Search
Fetch
Puppeteer
Wikipedia

You can also set up your own MCP tools using Spring AI conventions. See the application-docker-desktop.yml file for an example.

If you're running Ollama locally, include the embabel ollama starter and Embabel will automatically connect to your Ollama endpoint and make all models available.


<dependency>
    <groupId>com.embabel.agent</groupId>
    <artifactId>embabel-agent-starter-ollama</artifactId>
</dependency>

Running

Create your own agent project with

uvx --from git+https://github.com/embabel/project-creator.git project-creator

Example Agents

📚 For examples and tutorials, see the Embabel Agent Examples Repository

# Clone and run examples
git clone https://github.com/embabel/embabel-agent-examples
cd embabel-agent-examples/scripts/kotlin
./shell.sh

Shell Commands

Spring Shell is an easy way to interact with the Embabel agent framework, especially during development.

Type help to see available commands. Use execute or x to run an agent:

execute "Lynda is a Scorpio, find news for her" -p -r

This will look for an agent, choose the star finder agent and run the flow. -p will log prompts -r will log LLM responses. Omit these for less verbose logging.

Options:

-p logs prompts
-r logs LLM responses

Use the chat command to enter an interactive chat with the agent. It will attempt to run the most appropriate agent for each command.

Spring Shell supports history. Type !! to repeat the last command. This will survive restarts, so is handy when iterating on an agent.

Further examples

Example commands within the shell:

# Perplexity style deep research
# Requires both OpenAI and Anthropic keys and Docker Desktop with the MCP extension (or your own web tools)
execute "research the recent australian federal election. what is the position of the greens party?"

# x is a shortcut for execute
x "fact check the following: holden cars are still made in australia; the koel is a bird native only to australia; fidel castro is justin trudeau's father"

Bringing in additional LLMs

Local models with well-known providers

The Embabel Agent Framework supports local models from:

Ollama: Simply add embabel-agent-starter-ollama starter to your pom.xml and your local Ollama endpoint will be queries. All local models will be available.
Docker: Add the embabel-agent-starter-dockermodels starter to your pom.xml and your local Docker endpoint will be queried. All local models will be available.
LMStudio: This uses the openAI compatible client. Just include LMStudio as a dependency and make sure your LMStudio server is running.

Custom LLMs

You can define an LLM for any provider for which a Spring AI ChatModel is available.

Simply define Spring beans of type Llm. See the OpenAiConfiguration class as an example.

Remember:

Provide the knowledge cutoff date if you know it
Make the configuration class conditional on any required API key.

Roadmap

This project is in its early stages, but we have big plans. The milestones and issues in this repository are a good reference. Our key goals:

Become the natural way to Gen AI-enable Java applications, and especially those built on Spring.
Prove the power of the approach. Demonstrate that this approach is the best way to build safe, dependable, Gen AI applications. In particular:
- Demonstrate the power of extensibility without modification, by adding goals and actions
- Demonstrate the potential to become the PaaS for natural language
- Demonstrate the potential of agent federation within the GOAP model
- Demonstrate budget-aware agents, such as "Research the following topic, spending up to 20c if you are still learning"
- Integrate with data stores and demonstrate the power of surfacing existing functionality inside an organization
Take the model to other platforms: The conceptual framework is not JVM specific. Once established, we intend to create TypeScript and Python projects.

There is a lot to do, and you are awesome. We look forward to your contribution!

Application Design

Domain objects

Applications center around domain objects. These can be instantiated by LLMs or user code, and manipulated by user code.

Use Jackson annotations to help LLMs with descriptions as well as mark fields to ignore. For example:

@JsonClassDescription("Person with astrology details")
data class StarPerson(
    override val name: String,
    @get:JsonPropertyDescription("Star sign")
    val sign: String,
) : Person

See Java Json Schema Generation - Module Jackson for documentation of the library used.

Domain objects can have behaviors that are automatically exposed to LLMs when they are in scope. Simply annotate methods with the Spring AI @Tool annotation.

When exposing @Tool methods on domain objects, be sure that the tool is safe to invoke. Even the best LLMs can get trigger-happy. For example, be careful about methods that can mutate or delete data. This is likely better modeled via an explicit call to a non-tool method on the same domain class, in a code action.

Using Embabel as an MCP server

You can use the Embabel agent platform as an MCP server from a UI like Claude Desktop. The Embabel MCP server is available over SSE.

Configure Claude Desktop as follows in your claude_desktop_config.yml:

{
  "mcpServers": {
    "embabel": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "http://localhost:8080/sse"
      ]
    }
  }
}

See MCP Quickstart for Claude Desktop Users for how to configure Claude Desktop.

The MCP Inspector is a helpful tool for interacting with your Embabel SSE server, manually invoking tools and checking the exposed prompts and resources.

Start the MCP Inspector with:

npx @modelcontextprotocol/inspector

Consuming MCP Servers

The Embabel Agent Framework provides built-in support for consuming Model Context Protocol (MCP) servers, allowing you to extend your applications with powerful AI capabilities through standardized interfaces.

What is MCP?

Model Context Protocol (MCP) is an open protocol that standardizes how applications provide context and extra functionality to large language models. Introduced by Anthropic, MCP has emerged as the de facto standard for connecting AI agents to tools, functioning as a client-server protocol where:

Clients (like Embabel Agent) send requests to servers
Servers process those requests to deliver necessary context to the AI model

MCP simplifies integration between AI applications and external tools, transforming an "M×N problem" into an "M+N problem" through standardization - similar to what USB did for hardware peripherals.

Configuring MCP in Embabel Agent

To configure MCP servers in your Embabel Agent application, add the following to your application.yml:

spring:
  ai:
    mcp:
      client:
        enabled: true
        name: embabel
        version: 1.0.0
        request-timeout: 30s
        type: SYNC
        stdio:
          connections:
            docker-mcp:
              command: docker
              args:
                - run
                - -i
                - --rm
                - alpine/socat
                - STDIO
                - TCP:host.docker.internal:8811

This configuration sets up an MCP client that connects to a Docker-based MCP server. The connection uses STDIO transport through Docker's socat utility to connect to a TCP endpoint.

Docker Desktop MCP Integration

Docker has embraced MCP with their Docker MCP Catalog and Toolkit, which provides:

Centralized Discovery - A trusted hub for discovering MCP tools integrated into Docker Hub
Containerized Deployment - Run MCP servers as containers without complex setup
Secure Credential Management - Centralized, encrypted credential handling
Built-in Security - Sandbox isolation and permissions management

The Docker MCP ecosystem includes over 100 verified tools from partners like Stripe, Elastic, Neo4j, and more, all accessible through Docker's infrastructure.

Learn More

A2A

Embabel integrates with the A2A protocol, allowing you to connect to other A2A-enabled agents and services.

Enable the a2a Spring profile to start the A2A server.

You'll need the following environment variable:

GOOGLE_STUDIO_API_KEY: Your Google Studio API key, which is used for Gemini.

Start the Google A2A web interface using the a2a Docker profile:

docker compose --profile a2a up

Go to the web interface running within the container at http://localhost:12000/.

Connect to your agent at host.docker.internal:8080/a2a. Note that localhost:8080/a2a won't work as the server cannot access it when running in a Docker container.

Running Tests

Unit tests

Run the unit tests via Maven. This will not require an internet connection or any external services.

mvn test

Integration tests

Integration tests (*IT) hit real provider APIs and are excluded from the default mvn test run. To run them, ensure the following environment variables are set:

OPENAI_API_KEY
ANTHROPIC_API_KEY
DEEPSEEK_API_KEY
MISTRAL_API_KEY

Then run:

mvn -Dtest='*IT,!LLMOllama*IT' -Dsurefire.failIfNoSpecifiedTests=false test

This runs all integration tests except Ollama (which requires a local Ollama server). To run a specific module's integration tests, add -pl:

mvn -Dtest='*IT,!LLMOllama*IT' -Dsurefire.failIfNoSpecifiedTests=false test -pl embabel-agent-openai

Spring profiles

Spring profiles are used to configure the application for different environments and behaviors.

Model profiles:

docker-desktop: Talking to Docker Desktop with the MCP extension. This is recommended for the best experience, with Docker-provided web tools.

Logging profiles:

severance: Severance specific logging. Praise Kier!
starwars: Star Wars specific logging. Feel the force
colossus: Colossus specific logging. The Forbin Project.

Testing

A key goal of this framework is ease of testing. Just as Spring eased testing of early enterprise Java applications, this framework facilitates testing of AI applications.

Types of testing:

Unit tests: All agents are unit testable, like any Spring-managed beans. Construct them with mock objects; call individual action methods. The testing library facilitates testing prompts.
Integration tests: tbd

Logging

All logging in this project is either debug logging in the relevant class itself, or results from the stream of events of type AgentEvent.

Edit application.yml if you want to see debug logging from the relevant classes and packages.

Available logging experiences:

severance: Severance logging. Praise Kier
starwars: Star Wars logging. Feel the force. The default as it's understood throughout the galaxy.
colossus: Colossus logging. The Forbin Project.
montypython: Monty Python logging. No one expects it.
hh: Hitchhiker's Guide to the Galaxy logging. The answer is 42.

If none of these profiles is chosen, Embabel will use vanilla logging. This makes me sad.

Adding Embabel Agent Framework to Your Project

Maven Central Availability

Since version 0.2.0, Embabel Agent Framework is available directly on Maven Central, simplifying dependency management. You no longer need to configure custom repositories for stable releases.

Maven

For version 0.2.0 and above (Recommended)

Simply add the Embabel Spring Boot starter dependency to your pom.xml:


<dependency>
    <groupId>com.embabel.agent</groupId>
    <artifactId>embabel-agent-starter</artifactId>
    <version>${embabel-agent.version}</version>
</dependency>

No additional repository configuration is needed! Maven Central is configured by default.

For versions prior to 0.2.0 or for SNAPSHOT versions

You need to add the Embabel repositories to your pom.xml:


<repositories>
    <repository>
        <id>embabel-releases</id>
        <url>https://repo.embabel.com/artifactory/libs-release</url>
        <releases>
            <enabled>true</enabled>
        </releases>
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
    </repository>
    <repository>
        <id>embabel-snapshots</id>
        <url>https://repo.embabel.com/artifactory/libs-snapshot</url>
        <releases>
            <enabled>false</enabled>
        </releases>
        <snapshots>
            <enabled>true</enabled>
        </snapshots>
    </repository>
</repositories>

Then add the dependency:


<dependency>
    <groupId>com.embabel.agent</groupId>
    <artifactId>embabel-agent-starter</artifactId>
    <version>${embabel-agent.version}</version>
</dependency>

Gradle (Kotlin DSL)

For version 0.2.0 and above (Recommended)

Add the required repositories to your build.gradle.kts:

repositories {
    mavenCentral()
    maven {
        name = "Spring Milestones"
        url = uri("https://repo.spring.io/milestone")
    }
}

Add the Embabel Agent starter:

dependencies {
    implementation("com.embabel.agent:embabel-agent-starter:${embabelAgentVersion}")
}

For versions prior to 0.2.0 or for SNAPSHOT versions

Add all required repositories to your build.gradle.kts:

repositories {
    mavenCentral()
    maven {
        name = "embabel-releases"
        url = uri("https://repo.embabel.com/artifactory/libs-release")
        mavenContent {
            releasesOnly()
        }
    }
    maven {
        name = "embabel-snapshots"
        url = uri("https://repo.embabel.com/artifactory/libs-snapshot")
        mavenContent {
            snapshotsOnly()
        }
    }
    maven {
        name = "Spring Milestones"
        url = uri("https://repo.spring.io/milestone")
    }
}

Add the Embabel Agent starter:

dependencies {
    implementation("com.embabel.agent:embabel-agent-starter:${embabelAgentVersion}")
}

Gradle (Groovy DSL)

For version 0.2.0 and above (Recommended)

Add the required repositories to your build.gradle:

repositories {
    mavenCentral()
    maven {
        name = 'Spring Milestones'
        url = 'https://repo.spring.io/milestone'
    }
}

Add the Embabel Agent starter:

dependencies {
    implementation "com.embabel.agent:embabel-agent-starter:${embabelAgentVersion}"
}

For versions prior to 0.2.0 or for SNAPSHOT versions

Add all required repositories to your build.gradle:

repositories {
    mavenCentral()
    maven {
        name = 'embabel-releases'
        url = 'https://repo.embabel.com/artifactory/libs-release'
        mavenContent {
            releasesOnly()
        }
    }
    maven {
        name = 'embabel-snapshots'
        url = 'https://repo.embabel.com/artifactory/libs-snapshot'
        mavenContent {
            snapshotsOnly()
        }
    }
    maven {
        name = 'Spring Milestones'
        url = 'https://repo.spring.io/milestone'
    }
}

Add the Embabel Agent starter:

dependencies {
    implementation 'com.embabel.agent:embabel-agent-starter:${embabelAgentVersion}'
}

Important Notes

Spring Milestones Repository

The Spring Milestones repository is required because the Embabel BOM (embabel-agent-dependencies) has transitive dependencies on experimental Spring components, specifically the mcp-bom. This BOM is not available on Maven Central and is only published to the Spring milestone repository.

Note for Gradle users: Unlike Maven, Gradle does not inherit repository configurations declared in parent POMs or BOMs. Therefore, it is necessary to explicitly declare the Spring milestone repository in your repositories block to ensure proper resolution of all transitive dependencies.

Repository Types

Maven Central (since v0.2.0): For stable releases 0.2.0 and above
Embabel Releases Repository: For stable releases prior to 0.2.0
Embabel Snapshots Repository: For development/snapshot versions (e.g., 0.3.0-SNAPSHOT)

Quick Start Examples

Maven with latest stable version


<dependency>
    <groupId>com.embabel.agent</groupId>
    <artifactId>embabel-agent-starter</artifactId>
    <version>0.3.0</version>
</dependency>

Gradle Kotlin DSL with latest stable version

implementation("com.embabel.agent:embabel-agent-starter:0.3.0")

Gradle Groovy DSL with latest stable version

implementation 'com.embabel.agent:embabel-agent-starter:0.3.0'

Getting Started with Observability

Add full tracing and metrics to your Embabel agents with zero code changes.

1. Add the dependency

<dependency>
    <groupId>com.embabel.agent</groupId>
    <artifactId>embabel-agent-starter-observability</artifactId>
    <version>${embabel-agent.version}</version>
</dependency>

2. Add an exporter

Pick one (or combine multiple):

Zipkin (simplest — no account needed):

<dependency>
    <groupId>io.opentelemetry</groupId>
    <artifactId>opentelemetry-exporter-zipkin</artifactId>
</dependency>

Langfuse (LLM-focused observability):

<dependency>
    <groupId>com.quantpulsar</groupId>
    <artifactId>opentelemetry-exporter-langfuse</artifactId>
    <version>0.4.0</version>
</dependency>

3. Configure

# Enable observability
embabel:
  observability:
    enabled: true
    service-name: my-agent-app

# Enable Spring Boot tracing
management:
  tracing:
    enabled: true
    sampling:
      probability: 1.0

  # Zipkin exporter
  zipkin:
    tracing:
      endpoint: http://localhost:9411/api/v2/spans

To use Langfuse instead of (or alongside) Zipkin:

management:
  langfuse:
    enabled: true
    endpoint: https://cloud.langfuse.com/api/public/otel  # or your self-hosted URL
    public-key: pk-lf-...
    secret-key: sk-lf-...

4. Start Zipkin and run

docker run -d -p 9411:9411 openzipkin/zipkin
./mvnw spring-boot:run

Open http://localhost:9411 — run an agent and you will see traces like:

Agent: CustomerServiceAgent
├── Action: AnalyzeRequest
│   └── ChatModel: gpt-4 (Spring AI)
│       └── tool:searchKnowledgeBase
├── Action: GenerateResponse
│   └── ChatModel: gpt-4 (Spring AI)
└── status: completed [duration=2340ms]

With Langfuse, you get a rich LLM-focused view of your agent traces:

What gets traced automatically

Agent lifecycle (creation, execution, completion, failures)
Every action as a child span
LLM calls with token usage (via Spring AI)
Tool invocations with input/output
Planning and replanning iterations
State transitions and lifecycle states

Track custom operations with `@Tracked`

Use the @Tracked annotation to add observability spans to your own methods — inputs, outputs, duration, and errors are captured automatically:

@Tracked("enrichCustomer")
public Customer enrich(Customer input) {
    // Your logic here
}

You can specify a type and description for richer traces:

@Tracked(value = "callPaymentApi", type = TrackType.EXTERNAL_CALL, description = "Payment gateway call")
public PaymentResult processPayment(Order order) {
    // ...
}

When called within an agent execution, @Tracked spans are automatically nested under the current action:

Agent: CustomerServiceAgent
├── Action: ProcessOrder
│   ├── @Tracked: enrichCustomer (PROCESSING)
│   ├── ChatModel: gpt-4
│   └── @Tracked: callPaymentApi (EXTERNAL_CALL)
└── status: completed

For the full configuration reference, MDC log correlation, and advanced options, see the Observability Module Documentation.

Contributing

We welcome contributions to the Embabel Agent Framework.

Look at the coding style guide for style guidelines. This file also informs coding agent behavior.

Miscellaneous

Why the name Embabel? The "babel" part is ultimately inspired by the story of the Tower of Babel, perhaps via Douglas Adams' babelfish. Per @lasuac: While Adams' fish in the ear enabled universal translation between species, Embabel aims at translating human intent to JVM code, AI models, and enterprise systems. "embabel" also sounds like "enable."
Milestone names are Australian animals. Mythical animals such as "bunyip" and "yowie" are used for futures that may or not be implemented.
README badges come from here and here.
Don't forget to join Discord to collaborate with the Embabel community. It is a good place to receive support, showcase your work, discuss ideas and connect with like-minded people.

Star history

Contributors

JunkFood02/Seal

🦭 Video/Audio Downloader for Android, based on yt-dlp

Seal

Video/Audio Downloader for Android

📱 Screenshots

📖 Features

Download videos and audio files from video platforms supported by yt-dlp (formerly youtube-dl).
Embed metadata and video thumbnail into extracted audio files supported by mutagen.
Download all videos in the playlist with one click.
Use embedded aria2c as external downloader for all your downloads.
Embed subtitles into the downloaded videos.
Execute custom yt-dlp commands with templates.
Manage in-app downloads and custom command templates.
Easy to use and user-friendly.
Material Design 3 style UI, with dynamic color theme.
MAD: UI and logic written with pure Kotlin. Single activity, no fragments, only composable destinations.

⬇️ Download

For most devices, it is recommended to install the arm64-v8a version of the apks

Download the latest stable version from GitHub releases
- Install the pre-release versions to help us test out new features & changes
Stable releases are also available on F-Droid

💬 Contact

Join our Telegram Channel or Matrix Space for discussion, announcements, and releases!

💖 Sponsors

Seal will be always free and open source for everyone. If you like it, please consider sponsoring me!

🤝 Contributing

Contributions are welcome!

You can help translate Seal on Hosted Weblate.

Note

For submitting bug reports, feature requests, questions, or any other ideas to improve, please read CONTRIBUTING.md for instructions and guidelines first.

⭐️ Star History

🧱 Credits

Seal is a simple GUI of yt-dlp, based on youtubedl-android

Some of the UI designs and codes are borrowed from Read You and Music You

dvd

Material color utilities

Monet

📃 License

Warning

Except for the source code licensed under the GPLv3 license, all other parties are prohibited from using Seal's name as a downloader app, and the same is true for Seal's derivatives. Derivatives include but are not limited to forks and unofficial builds.

👆 Scroll to top

RikkaApps/Shizuku

Using system APIs directly with adb/root privileges from normal apps through a Java process started with app_process.

Shizuku

Background

When developing apps that requires root, the most common method is to run some commands in the su shell. For example, there is an app that uses the pm enable/disable command to enable/disable components.

This method has very big disadvantages:

Extremely slow (Multiple process creation)
Needs to process texts (Super unreliable)
The possibility is limited to available commands
Even if ADB has sufficient permissions, the app requires root privileges to run

Shizuku uses a completely different way. See detailed description below.

User guide & Download

https://shizuku.rikka.app/

How does Shizuku work?

First, we need to talk about how app use system APIs. For example, if the app wants to get installed apps, we all know we should use PackageManager#getInstalledPackages(). This is actually an interprocess communication (IPC) process of the app process and system server process, just the Android framework did the inner works for us.

Android uses binder to do this type of IPC. Binder allows the server-side to learn the uid and pid of the client-side, so that the system server can check if the app has the permission to do the operation.

Usually, if there is a "manager" (e.g., PackageManager) for apps to use, there should be a "service" (e.g., PackageManagerService) in the system server process. We can simply think if the app holds the binder of the "service", it can communicate with the "service". The app process will receive binders of system services on start.

Shizuku guides users to run a process, Shizuku server, with root or ADB first. When the app starts, the binder to Shizuku server will also be sent to the app.

The most important feature Shizuku provides is something like be a middle man to receive requests from the app, sent them to the system server, and send back the results. You can see the transactRemote method in rikka.shizuku.server.ShizukuService class, and moe.shizuku.api.ShizukuBinderWrapper class for the detail.

So, we reached our goal, to use system APIs with higher permission. And to the app, it is almost identical to the use of system APIs directly.

Developer guide

API & sample

https://github.com/RikkaApps/Shizuku-API

Migrating from pre-v11

Existing applications still works, of course.

https://github.com/RikkaApps/Shizuku-API#migration-guide-for-existing-applications-use-shizuku-pre-v11

Attention

ADB permissions are limited

ADB has limited permissions and different on various system versions. You can see permissions granted to ADB here.

Before calling the API, you can use ShizukuService#getUid to check if Shizuku is running user ADB, or use ShizukuService#checkPermission to check if the server has sufficient permissions.
Hidden API limitation from Android 9

As of Android 9, the usage of the hidden APIs is limited for normal apps. Please use other methods (such as https://github.com/LSPosed/AndroidHiddenApiBypass).
Android 8.0 & ADB

At present, the way Shizuku service gets the app process is to combine IActivityManager#registerProcessObserver and IActivityManager#registerUidObserver (26+) to ensure that the app process will be sent when the app starts. However, on API 26, ADB lacks permissions to use registerUidObserver, so if you need to use Shizuku in a process that might not be started by an Activity, it is recommended to trigger the send binder by starting a transparent activity.
Direct use of transactRemote requires attention
- The API may be different under different Android versions, please be sure to check it carefully. Also, the android.app.IActivityManager has the aidl form in API 26 and later, and android.app.IActivityManager$Stub exists only on API 26.
- SystemServiceHelper.getTransactionCode may not get the correct transaction code, such as android.content.pm.IPackageManager$Stub.TRANSACTION_getInstalledPackages does not exist on API 25 and there is android.content.pm.IPackageManager$Stub.TRANSACTION_getInstalledPackages_47 (this situation has been dealt with, but it is not excluded that there may be other circumstances). This problem is not encountered with the ShizukuBinderWrapper method.

Developing Shizuku itself

Build

Clone with git clone --recurse-submodules
Run gradle task :manager:assembleDebug or :manager:assembleRelease

The :manager:assembleDebug task generates a debuggable server. You can attach a debugger to shizuku_server to debug the server. Be aware that, in Android Studio, "Run/Debug configurations" - "Always install with package manager" should be checked, so that the server will use the latest code.

License

All code files in this project are licensed under Apache 2.0

Under Apache 2.0 section 6, specifically:

You are FORBIDDEN to use manager/src/main/res/mipmap*/ic_launcher*.png image files, unless for displaying Shizuku itself.
You are FORBIDDEN to use Shizuku as app name or use moe.shizuku.privileged.api as application id or declare moe.shizuku.manager.permission.* permission.

AAswordman/Operit

The most powerful AI agent and AI chat software on Android/Operit是一款Android上能力最为强大、发展最久的AI Agent

中文 | English

Operit AI - 智能助手应用

📱 移动端首个功能完备的AI智能助手应用，完全独立运行，拥有强大的工具调用能力 📱

🌟 项目简介

Operit AI 是移动端首个功能完备的 AI 智能助手应用，完全独立运行于您的 Android 设备上（除API调用），拥有强大的工具调用能力、深度搜索、工作流与自动化、智能记忆库，并支持人设定制与角色卡等高度自定义功能，集成 MNN/llama.cpp 本地模型、MCP/Skill 生态与多语言界面。它不仅仅是聊天界面，更是与Android权限和各种工具深度融合的全能助手，内置Ubuntu 24 环境，提供前所未有的强大功能。

⚡ 核心亮点

🖥️ Ubuntu 24 环境

内置完整 Ubuntu 24 系统，支持 vim、MCP、Python等工具，在手机上运行复杂的Linux命令和自动化任务

🧠 智能记忆系统

AI自动分类管理记忆，支持时间查询/导入导出/自动总结，智能搜索历史对话，记住您的偏好和习惯，提供个性化服务

🗣️ 语音交互

连续自然对话，支持本地/云端 TTS + 本地 STT、自定义音色、语音/特定音频唤醒、自动朗读

🤖 本地AI模型

支持 MNN / llama.cpp 本地模型（GGUF），完全离线运行AI，保护隐私数据

🎭 人设与角色卡

自定义AI性格、说话风格，支持角色卡导入导出（酒馆/JSON）/备份/二维码分享，角色卡可互聊并拥有独立对话历史

🔌 丰富工具生态

40+ 内置工具 + MCP/Skill 市场插件 + 工具包/工作流，含自动点击 Agent、绘图/图片搜索、AI 互聊/自我认知、定时任务、提示词市场等，覆盖文件操作、网络请求、系统控制、媒体处理

🛠️ 功能速览

📦 内置工具系统（点击展开）

工具类型	功能说明
🐧 Linux环境	完整Ubuntu 24，支持apt包管理、Python/Node.js运行环境、自定义软件源
📁 文件系统	读写文件、搜索、解压缩、格式转换、Git集成
🌐 网络工具	HTTP请求、网页访问、文件上传下载、Web开发与导出
⚙️ 系统操作	安装应用、权限管理、无障碍 / ADB / Root 三通道自动化（含 AutoGLM 自动点击 Agent，支持 adb root 虚拟屏/多显示器）
🎬 媒体处理	视频转换、帧提取、OCR/图像理解、相机拍照、音视频读取
🧑‍💻 开发与终端	Web 工作区/一键打包、代码编辑/语法高亮、终端 SSH/Chroot/vim、Ctrl 组合键
🎨 AI 创作	绘图工具包（OpenAI/Qwen/NanoBanana）、图片搜索/下载
🔍 搜索引擎	深度搜索、DuckDuckGo、Tavily、谷歌学术、Bing、Sogou、Quark、百度地图集成
🧩 工具包 & 工作流	工具包生态/包管理、工作流自动化、定时触发、语音唤醒触发

🎨 界面定制（点击展开）

✨ 主题系统：自定义颜色、字体、间距、内边距
🌍 多语言支持：中英覆盖，自动随系统语言切换
🔤 字体与排版：全局字体大小、聊天边距自定义
🎭 桌宠功能：WebP动画支持、自定义表情、悬浮窗显示
📱 布局优化：隐藏状态栏、自定义工具栏、平板适配
🎨 Markdown渲染：LaTeX公式（支持左右滚动）、代码高亮、表格、Mermaid图表
🧾 信息展示：思考链折叠、HTML块预览、代码/思考块高度限制
🪟 悬浮窗体验：悬浮窗/气泡模式头像隐藏、圈选识屏、全屏预览
🧮 数据统计：Token 用量统计、模型饼图

🔗 集成能力（点击展开）

🤖 Tasker集成：触发自定义AI代理事件，深度自动化
🌐 MCP/Skill 市场：一键安装插件、远程MCP、自动描述、uvx/npx支持
🔌 多模型支持：OpenAI、Claude、Gemini、百灵、OpenRouter、LMStudio
🧪 模型与提示词管理：多配置/参数自定义、提示词市场
🔐 权限系统：工具级权限控制与安全提示
🔑 密钥池与统计：批量测试/导入、Token 统计（模型饼图）
🗂️ 工作区绑定：支持 SAF / SFTP / SSH 工作区绑定与文件访问
🖱️ 自动点击 Agent：AutoGLM + UI Tree 双通道，支持自动化操作
📊 工具并行：只读工具并行执行，提升响应速度

💬 对话与记忆管理（点击展开）

🧠 记忆库：自动分类/搜索、时间查询、导入导出、附件记忆
💬 对话管理：自动总结与总结编辑、历史分组/分支/迁移、对话锁定、角色卡独立历史
⚡ 对话并行：并行对话处理、工具包 state 决策
🤖 角色互动：角色卡互聊、查看历史、思考链折叠
📦 聊天记录：多格式导入导出、历史备份与恢复

💾 数据与备份（点击展开）

🗂️ 全局/自动备份：数据库定时备份，支持损坏恢复（排除 MCP/Skill/终端/包）
🎭 角色卡：备份、导出（酒馆/JSON）、二维码分享
🧷 工作区：SAF/SFTP/SSH 绑定、代码编辑/语法高亮、Git ignore
🧰 Skill 管理：Skill 开关、仓库解析与缓存下载

📸 功能展示

Web开发
在手机上设计网页并导出为独立应用

悬浮窗 & 附件
随时调用，便捷分享

插件市场
丰富的MCP生态

🚀 快速开始

项目	说明
📋 系统要求	Android 8.0+ (API 26+)，建议 4GB+ 内存，200MB+ 存储
📥 下载安装	Release页面下载最新APK
📖 使用指南	完整文档包含详细教程和示例

安全提示： 为确保您的数据安全，请务必从官方 Release页面或官方网站下载本应用。通过未知渠道下载的安装包可能被恶意修改，从而导致隐私泄露或设备被监听。

安装步骤： 下载APK → 安装启动 → 按引导配置 → 开始使用 ✨

🔮 TODO / 开发计划

UI 自动化与截图管线
- ✅ 已支持无障碍 / ADB / Root 三种权限模式的 UI 自动化
- ✅ 支持 adb root 场景下的虚拟屏幕/多显示器（display 参数）
- ✅ UI Tree 支持 AutoGLM + 本地 uiautomator dump 双方案

📅 版本更新历程

版本	发布日期	核心更新
v1.10.1 _最新	2026-04-17	• 内置浏览器与网页自动化：大幅增强内置浏览器，支持标签页、历史、书签、权限、多窗口、最小化与视口控制，并补齐浏览器脚本的导入、安装、启停、存储与页面菜单能力 • 虚拟形象与界面定制：支持 FBX 虚拟形象并升级 MMD 预览，新增液态玻璃主题效果，并增强侧边栏、聊天气泡与输入栏的外观自定义 • 插件、工作区与上下文增强：支持通过配置编辑器调试和自动编写 Operit 插件，新增本地 HTTP 对话入口、工作区重命名与规则文件自动读取，并增强历史跳转、双向分页与上下文自动补充能力 • 稳定性与性能优化：修复工具权限、HTTP TTS、SSH/tmux 长输出、历史跳转、GIF/公式/Markdown 渲染、MCP 配置与统计等问题，并持续优化对话链路、深度搜索、记忆系统、浏览器与包管理器
v1.10.0	2026-03-18	• 角色卡群聊与 AI 自配置：支持多个角色卡群聊与 @ 交互，新增 AI 自我设置能力，可辅助配置 MCP、Skill、STT、TTS 与模型参数 • 主题与交互升级：新增分组折叠消息、气泡主题及字体/颜色/背景自定义、更宽气泡、输入框液态玻璃、长按图标直达设置/语音模式，以及助手形象与 MP4 虚拟形象支持 • 工具与平台扩展：新增 Ollama、NVIDIA、OpenAI Response 通用模式，补充独立 SSH 插件工具包、Java Bridge、APKTool 插件、Web 自动化下载、Markdown 音视频渲染、xAI 视频生成、工作流取消、终端自定义按键与消息队列 • 修复与性能优化：修复语音识别、记忆并发、悬浮窗交互、终端显示、Web 自动化全屏、MNN Tool Call 等问题，并优化记忆召回、市场搜索、工作区模板、grep 工具性能与 Agent 重试稳定性
v1.9.1	2026-02-20	• 稳定性修复：集中修复 1.9.0 多项问题，提升整体可用性与流畅性 • 终端与工具调用：增强终端工具，修复交互 UI 卡住、严格工具调用历史工具报错、Windows 控制器 raw 命令执行问题 • MCP 与记忆库：修复远程 MCP 无法关闭，重做记忆库写入逻辑，支持外接向量模型并新增连接修改工具 • 功能补充与界面修复：新增未绑定角色卡聊天记录删除、工作流批量删除与执行日志查看，修复输入法/暗色输入框/主题透明度/工具箱包管理等问题
v1.9.0	2026-02-17	• 移动端网页自动操作：新增网页操作能力，支持工作区 Web 项目 CORS 绕过访问外部网页 • Windows 终端操作：支持 Windows 命令操作，可控制 Codex 等 CLI，新增严格工具调用模式补充兼容性 • 工具与系统扩展：新增 SQL 查看器、Android 工作区模板、OpenAI response 兼容供应商、skill 直接输入添加、统计饼图 • 修复与优化：修复图片读取/上下文总结/特殊符号截断/ffmpeg 等问题，增强模型连通性测试输出与 MCP 加载提示
v1.8.1	2026-02-03	• llama.cpp 本地推理：支持 GGUF 本地模型与相关工具 • 工具与界面：图片搜索/下载、HTML 块预览、代码/思考块高度限制、气泡头像隐藏、Token 饼图、思考链折叠 • 数据与备份：全局备份（排除 MCP/skill/终端/包）+ 角色卡备份/导出/分享、Skill 开关、密钥池导入/批量测试、工作区支持 SAF 绑定 • 修复：AI 朗读回声录制、悬浮窗 Token 统计、角色编辑键盘遮挡、深搜 Token 爆炸、MCP 启动、工作流悬浮窗退出、表格截断、硅基流动语音打断
v1.8.0	2026-01-13	• 工作流系统：支持计算/传入传出/执行等能力，并支持语音唤醒触发 • 语音唤醒：直接进入语音对话模式，支持语音下关键词快速附件附着 • 对话并行：支持对话并行处理，工具包 state 机制可动态决定工具 • 新增与优化：记忆时间查询、自动备份、OpenAI 绘图/语音供应商、MCP 启动优化、终端 chroot、修复多项 BUG
v1.7.1	2025-12-31	• Root 虚拟屏幕自动化：支持 root 启动虚拟屏幕，AutoGLM 并发多窗口任务 • Skill 生态：新增 Skill 协议与 Skill 市场，并支持 BETA 计划追踪 nightly • 交互增强：总结编辑、网页访问改悬浮窗模式、圈选识屏、对话锁定 • 修复与优化：大图崩溃、ToolCall 错误、代码块换行、启动速度与虚拟屏稳定性
v1.7.0	2025-12-19	• GUI 自动化里程碑：Autoglm + 虚拟屏幕（可在设置中开关虚拟屏幕） • 自动化增强：一键 Autoglm 配置与单独执行器，虚拟屏开关逻辑与截图质量自定义 • 体验优化：密钥非聚焦显示为星号，强制不允许 Autoglm 设置为主模型 • 工具扩展：NanoBanana 绘图包、apply file 非覆盖支持、MNN STT 等
v1.6.3	2025-12-08	• 原生ToolCall支持：支持原生模型工具调用、DeepSeek思考工具 • 工作区与终端增强：新建时选择项目类型、SSH文件系统连接、终端无障碍支持 • 模型与消息显示：支持模型配置多选、消息显示模型名称与提供者 • 优化与修复：优化悬浮窗、修复终端卡顿、迁移工作区到内部存储
v1.6.2	2025-11-20	• 对话管理增强：长按开分支、历史记录分类显示、批量迁移 • 模型配置优化：配置重命名、上下文绑定、谷歌原生搜索 • Bug修复：界面切换、粗体换行、气泡模式等问题 • 增加crossref学术论文检索包、升级代码编辑器
v1.6.1	2025-11-05	• 性能大优化：重做UI绘制，大幅提升流畅性 • AI视觉增强：直接识别图片、间接识别能力 • 终端SSH：支持SSH连接和反向挂载手机文件系统 • 自动总结机制、深度搜索、新授权系统
v1.6.0	2025-10-21	• MNN本地模型支持 • 记忆库大更新：AI自动分类、智能搜索、导入导出 • 终端优化：vim支持、进度条、自定义软件源 • Tasker集成、桌宠功能、故事线标签
v1.5.2	2025-10-05	• MCP增强：uvx/npx支持、启动加速 • 工作区 Git ignore • 相机拍照、HTML渲染、正则过滤
v1.5.0	2025-09	• Ubuntu 24终端完整集成 • MCP市场上线 • 桌宠功能、深度搜索模式
v1.4.0	2025-08	• 多工具并行执行 • 人设卡系统、角色选择器 • PNG角色卡导入
v1.3.0	2025-08	• Web开发功能 • 主题选择器、自定义UI • Anthropic Claude支持
v1.2.x	2025-07	• 语音对话系统 • 知识库功能 • DragonBones动画支持
v1.1.x	2025-06	• MCP协议支持 • OCR识别、悬浮窗 • Gemini完整支持
v1.0.0	2025-05	• 首个正式版本 • 基础AI对话、工具调用 • Shizuku/Root集成

📝 完整更新日志：访问 Releases 页面查看每个版本的详细更新内容

👨‍💻 开源共创

欢迎加入 Operit 开源生态！我们欢迎各种贡献：第三方脚本、MCP插件、核心功能开发。

开发者须知：

📚 开源共创指南 | 脚本开发指南
📦 构建项目需从 Google Drive 下载依赖库压缩包（models.zip、subpack.zip、jniLibs.zip、libs.zip）
💬 加入社区讨论：QQ群 | Discord

💖 贡献者

感谢所有为 Operit AI 做出贡献的人！

💖 支持开发

如果 Operit AI 对您有帮助，欢迎自愿支持项目持续开发与基础运营：

海外支持可使用 Patreon
境内支持可使用爱发电
赞助完全自愿，不与任何功能、额度、更新、答疑或其他权益挂钩
即使不赞助，也不影响正常使用、获取更新或访问开源代码
您也可以直接使用 GitHub 仓库顶部的 Sponsor 按钮进入赞助页面

📄 许可证

本项目采用 GNU LGPLv3 许可证。

简单来说，这意味着：

您可以自由地使用、修改和分发本项目的代码。
如果您修改了代码并进行分发，您也必须以 LGPLv3 许可证开源您修改过的部分。
详细信息请参阅 LICENSE 文件。

📝 问题反馈

遇到问题或有建议？欢迎提交 Issue！

提交指南：

📝 清晰描述问题/建议，提供复现步骤
📱 附上设备型号、系统版本等信息
📸 如有可能，提供截图或录屏

⭐ 如果觉得项目不错，请给我们一个 Star ⭐

🚀 帮助我们推广，让更多人了解 Operit AI 🚀

_{Made with ❤️ by the Operit Team}

google-ai-edge/gallery

A gallery that showcases on-device ML/GenAI use cases and allows people to try and use models locally.

Google AI Edge Gallery ✨

Explore, Experience, and Evaluate the Future of On-Device Generative AI with Google AI Edge.

AI Edge Gallery is the premier destination for running the world's most powerful open-source Large Language Models (LLMs) on your mobile device. Experience high-performance Generative AI directly on your hardware—fully offline, private, and lightning-fast.

Now Featuring: Gemma 4

The latest version brings official support for the newly released Gemma 4 family. As the centerpiece of this release, Gemma 4 allows you to test the cutting edge of on-device AI. Experience advanced reasoning, logic, and creative capabilities without ever sending your data to a server.

Install the app today from Google Play	Install the app today from App Store

For users without Google Play access, install the apk from the latest release

App Preview

✨ Core Features

Agent Skills: Transform your LLM from a conversationalist into a proactive assistant. Use the Agent Skills tile to augment model capabilities with tools like Wikipedia for fact-grounding, interactive maps, and rich visual summary cards. You can even load modular skills from a URL or browse community contributions on GitHub Discussions.
AI Chat with Thinking Mode: Engage in fluid, multi-turn conversations and toggle the new Thinking Mode to peek "under the hood." This feature allows you to see the model’s step-by-step reasoning process, which is perfect for understanding complex problem-solving. Note: Thinking Mode currently works with supported models, starting with the Gemma 4 family.
Ask Image: Use multimodal power to identify objects, solve visual puzzles, or get detailed descriptions using your device’s camera or photo gallery.
Audio Scribe: Transcribe and translate voice recordings into text in real-time using high-efficiency on-device language models.
Prompt Lab: A dedicated workspace to test different prompts and single-turn use cases with granular control over model parameters like temperature and top-k.
Mobile Actions: Unlock offline device controls and automated tasks powered entirely by a finetune of FunctionGemma 270m.
Tiny Garden: A fun, experimental mini-game that uses natural language to plant and harvest a virtual garden using a finetune of FunctionGemma 270m.
Model Management & Benchmark: Gallery is a flexible sandbox for a wide variety of open-source models. Easily download models from the list or load your own custom models. Manage your model library effortlessly and run benchmark tests to understand exactly how each model performs on your specific hardware.
100% On-Device Privacy: All model inferences happen directly on your device hardware. No internet is required, ensuring total privacy for your prompts, images, and sensitive data.

🏁 Get Started in Minutes!

Check OS Requirement: Android 12 and up, and iOS 17 and up.
Download the App:
- Install the app from Google Play or App Store.
- For users without Google Play access: install the apk from the latest release
Install & Explore: For detailed installation instructions (including for corporate devices) and a full user guide, head over to our Project Wiki!

🛠️ Technology Highlights

Google AI Edge: Core APIs and tools for on-device ML.
LiteRT: Lightweight runtime for optimized model execution.
Hugging Face Integration: For model discovery and download.

⌨️ Development

Check out the development notes for instructions about how to build the app locally.

🤝 Feedback

This is an experimental Beta release, and your input is crucial!

🐞 Found a bug? Report it here!
💡 Have an idea? Suggest a feature!

📄 License

Licensed under the Apache License, Version 2.0. See the LICENSE file for details.

🔗 Useful Links

iamgio/quarkdown

🪐 Markdown with superpowers: from ideas to papers, presentations, websites, books, and knowledge bases.

Releases
Latest | Stable

About

Quarkdown is a modern Markdown-based typesetting system designed for versatility. It allows a single project to compile seamlessly into a print-ready book, academic paper, knowledge base, or interactive presentation. All through an incredibly powerful Turing-complete extension of Markdown, ensuring your ideas flow automatically into paper.

Original credits: Attention Is All You Need

Born as an extension of CommonMark and GFM, the Quarkdown Flavor brings functions to Markdown, along with many other syntax extensions.

This is a function call:
.somefunction {arg1} {arg2}
    Body argument

Possibilities are unlimited thanks to an ever-expanding standard library, which offers layout builders, I/O, math, conditional statements and loops.

Not enough? You can still define your own functions and variables, all within Markdown. You can even create awesome libraries for everyone to use.

.function {greet}
    to from:
    **Hello, .to** from .from!

.greet {world} from:{iamgio}

Result: Hello, world from iamgio!

This out-of-the-box scripting support opens doors to complex and dynamic content that would be otherwise impossible to achieve with vanilla Markdown.

Combined with live preview, ⚡ fast compilation speed and a powerful VS Code extension, Quarkdown simply gets the work done, whether it's an academic paper, book, knowledge base or interactive presentation.

Looking for something?

Check out the wiki to get started and learn more about the language and its features!

As simple as you expect...

Inspired by: X-ray flashes from a nearby supermassive black hole accelerate mysteriously

...as complex as you need.

Targets

HTML
- Plain
  Continuous flow like Notion/Obsidian, perfect for static websites and knowledge management - check out the author's personal website.
- Paged ^{via paged.js}
  Perfect for papers, articles and books - check out the demo document.
- Slides ^{via reveal.js}
  Perfect for interactive presentations.
- Docs
  Perfect for wikis, technical documentation and large knowledge bases - check out Quarkdown's wiki.
PDF
- All document types and features supported by HTML are also supported when exporting to PDF.
Plain text

The desired document type can be set by calling the .doctype function within the source itself:

.doctype {plain} (default)
.doctype {paged}
.doctype {slides}
.doctype {docs}

Comparison

	Quarkdown	LaTeX	Typst	AsciiDoc	MDX
Concise and readable	✅	❌	✅	✅	✅
Full document control^[1]	✅	✅	✅	❌	❌
Scripting	✅	Partial	✅	❌	✅
Book/article export	✅	✅	✅	✅	Third-party
Presentation export	✅	✅	✅	✅	Third-party
Static site export	✅	❌	Experimental	✅	✅
Docs/wiki export	✅	❌	❌	✅	✅
Learning curve	🟢	🔴	🟠	🟢	🟢
Targets	HTML, PDF, TXT	PDF, PostScript	HTML, PDF	HTML, PDF, ePub	HTML

LaTeX Quarkdown

LaTeX	Quarkdown
\tableofcontents \section{Section} \subsection{Subsection} \begin{enumerate} \item \textbf{First} item \item \textbf{Second} item \end{itemize} \begin{center} This text is \textit{centered}. \end{center} \begin{figure}[!h] \centering \begin{subfigure}[b] \includegraphics[width=0.3\linewidth]{img1.png} \end{subfigure} \begin{subfigure}[b] \includegraphics[width=0.3\linewidth]{img2.png} \end{subfigure} \begin{subfigure}[b] \includegraphics[width=0.3\linewidth]{img3.png} \end{subfigure} \end{figure}	`.tableofcontents # Section ## Subsection 1. First item 2. Second item .center This text is _centered_. .row alignment:{spacebetween} ![Image 1](img1.png) ![Image 2](img2.png) ![Image 3](img3.png)`

\tableofcontents

\section{Section}

\subsection{Subsection}

\begin{enumerate}
    \item \textbf{First} item
    \item \textbf{Second} item
\end{itemize}

\begin{center}
    This text is \textit{centered}.
\end{center}

\begin{figure}[!h]
    \centering
    \begin{subfigure}[b]
        \includegraphics[width=0.3\linewidth]{img1.png}
    \end{subfigure}
    \begin{subfigure}[b]
        \includegraphics[width=0.3\linewidth]{img2.png}
    \end{subfigure}
    \begin{subfigure}[b]
        \includegraphics[width=0.3\linewidth]{img3.png}
    \end{subfigure}
\end{figure}

.tableofcontents

# Section

## Subsection

1. **First** item
2. **Second** item

.center
    This text is _centered_.

.row alignment:{spacebetween}
    ![Image 1](img1.png)

    ![Image 2](img2.png)
    
    ![Image 3](img3.png)

Getting started

Installation

Install script (Linux/macOS)

curl -fsSL https://raw.githubusercontent.com/quarkdown-labs/get-quarkdown/refs/heads/main/install.sh | sudo env "PATH=$PATH" bash

Root privileges let the script install Quarkdown into /opt/quarkdown and its wrapper script into /usr/local/bin/quarkdown.
If missing, Java 17, Node.js and npm will be installed automatically using the system's package manager.

For more installation options, check out get-quarkdown.

Homebrew (Linux/macOS)

brew install quarkdown-labs/quarkdown/quarkdown

Install script (Windows)

irm https://raw.githubusercontent.com/quarkdown-labs/get-quarkdown/refs/heads/main/install.ps1 | iex

Scoop (Windows)

scoop bucket add java
scoop bucket add quarkdown https://github.com/quarkdown-labs/scoop-quarkdown
scoop install quarkdown

GitHub Actions

See setup-quarkdown to easily integrate Quarkdown into your GitHub Actions workflows.

Manual installation

Instructions for manual installation

Download quarkdown.zip from the latest stable release and unzip it, or build it with gradlew installDist.

Optionally, adding <install_dir>/bin to your PATH allows you easier access Quarkdown.

Requirements:

Java 17 or higher
(Only for PDF export) Node.js, npm, Puppeteer. See PDF export for details.

Quickstart 🆕

New user? You'll find everything you need in the Quickstart guide to bring life to your first document!

Creating a project

quarkdown create [directory] will launch the prompt-based project wizard, making it quicker than ever to set up a new Quarkdown project, with all metadata and initial content already present.

For more information about the project creator, check out its wiki page.

Alternatively, you may manually create a .qd source file and start from there.

Compiling

Running quarkdown c file.qd will compile the given file and save the output to file.

If the project is composed by multiple source files, the target file must be the root one, i.e. the one that includes the other files.

How to include other files?

If you would like to familiarize yourself with Quarkdown instead, quarkdown repl lets you play with an interactive REPL mode.

Options

The most commonly used options are:

-p or --preview: enables automatic content reloading after compiling.
-w or --watch: recompiles the source every time a file from the source directory is changed.

Tip

Combine -p -w to achieve live preview!

--pdf: produces a PDF file. Learn more in the wiki's PDF export page.

For the full list of options, check out the CLI options wiki page.

Mock document

Mock, written in Quarkdown, is a comprehensive collection of visual elements offered by the language, making it ideal for exploring and understanding its key features — all while playing and experimenting hands-on with a concrete outcome in the form of pages or slides.

The document's source files are available in the mock directory, and can be compiled via quarkdown c mock/main.qd -p.
The PDF artifacts generated for all possible theme combinations are available and can be viewed in the generated repo.

Contributing

Contributions are welcome! Please check CONTRIBUTING.md to know how contribute via issues or pull requests.

Concept

The logo resembles the original Markdown icon, with focus on Quarkdown's completeness, richness of features and customization options, emphasized by the revolving arrow all around the sphere.

What could be mistaken for a planet is actually a quark or, more specifically, a down quark, an elementary particle that is a major constituent of matter: they give life to every complex structure we know of, while also being one of the lightest objects in existence.

This is, indeed, the concept Quarkdown is built upon.

License

By default, Quarkdown and its modules are licensed under GNU GPLv3, except for modules that include their own LICENSE file: the CLI (quarkdown-cli) and Language Server (quarkdown-lsp) modules and binaries are licensed under GNU AGPLv3.

Footnotes

The ability to customize the properties of the document and of its output artifact through the language itself. ↩︎

breezy-weather/breezy-weather

A feature-rich weather app with good visualizations and more than 50 sources.

Breezy Weather

Breezy Weather is a feature-rich free and open source Material 3 Expressive weather app with well-though-out visualizations, supporting forecast, observations, nowcasting, air quality, pollen, alerts, from more than 50 weather sources.

⬇️ Download

All installation methods

SHA-256 hash of the signing certificate: 29d435f70aa9aec3c1faff7f7ffa6e15785088d87f06ecfcab9c3cc62dc269d8
SHA-256 checksums are also provided per file on the GitHub releases page.

✨ Features

🌤️ Weather data
- Daily and hourly forecasts up to 16 days
- Precipitation in the next hour
- Severe weather and precipitation alerts
- Temperature / Feels like temperature / Normals
- Precipitation
- Wind
- Air quality
- Pollen & Mold
- Humidity
- UV index
- Visibility
- Pressure
- Sun
- Moon
📊 Visualization
- Detailed 24-hour charts
- Material 3 Expressive blocks
🏭 More than 50 weather sources supported (full list)
🧩 Large selection of widgets
🖼️ Live wallpaper
📦 Custom icon packs
- Geometric Weather icon packs
- Chronus Weather icon packs
🌙 Automatic dark mode
🔁 Opt-in data sharing with other apps (such as Gadgetbridge)
🚹 Accessibility
- Localization
  - Number formatting (different numeral systems, decimal separator, thousand separator)
  - Unit formatting
  - Alternate calendar
- Readability
  - Good content descriptions for screen readers
  - Navigation with screen readers: most things should work, features depending on drag & drop not yet supported
  - Custom display settings: basic support

🆓 Free and Open Source
- No proprietary blobs/dependencies
- Releases generated by GitHub actions, guaranteeing it matches the source code
- Fully works with Open-Meteo (FOSS source)
- Separate flavor with only sources hosted on FOSS networks

🛡️ Privacy-friendly
- No personal data collected by the app (link to app privacy policy)
- Multiple sources are available, with links to their privacy policies for transparency
- Current location is optional and not added by default
- If using current location, an IP location service can be used instead of GPS to send less accurate coordinates to weather source
- No trackers/automatic crash reporters

🛟 Help

🤝 Contribute

Pull requests are welcome. You can have a look at issues opened to contributions. For other changes, please open an issue first to discuss what you would like to change.

Contribution guide (includes a guide to create a new weather source)

Features currently being worked on by a contributor

Announcement - Make Breezy weather data available through a ContentProvider. Landed in v6.1.0. Currently in an experimental phase; feedback appreciated
#10 - “Add location” page needs a new design, in the spirit of Google Maps where you can select location points on the map, or search manually - No mockup done yet

Features lacking an active contributor

#937 - Widget overhaul (prerequisite for any new widget improvement) - Some mockups were done but no one is working on it anymore

Features that will not be implemented

Paid-only sources, too limited free-tier, or free-tier that requires privacy-invasive information (credit card info, phone number, etc)
Radar; please check out this document for alternatives
Adding standard flavor or non-free sources to the F-Droid default repo: please use the standard flavor from a different store/source instead
Changes to the background updates process, including but not limited: options for refreshing less than every 30 minutes, every time you open the app, every time you tap on widget, every time you unlock your phone
“Circular sky” interface: you can set a fixed light/dark background globally from Main screen settings instead.
Publish to Google Play Store: please check alternatives
Allow different flavors to be installed in parallel
Implement features that are no longer available in latest Android versions
Backport features/fixes from latest Android versions to older Android versions
Donations: if you have extra money to spare, consider donating to Open-Meteo to support infrastructure costs and future developments (we currently lack a libre and gratis worldwide alternative for the following features: Reverse geocoding, Alerts, Normals)

🌍 Translations

Translation is done externally on Weblate. Please read carefully project instructions if you want to help.

English (and regional variants) and French translations are maintained by repo maintainers, but they are open to proofreading/improvements. You will need to make a pull request, as we didn’t find a way to make these languages in suggestion-only mode in Weblate (let us know if you find anything).

For unit formatting, we use Unicode data as much as possible. If you believe there is an error, please open a discussion with evidences that the changes you suggest is the recommendation for your language.

✉️ Contact us

If you’d like to report a bug or suggest a new feature, GitHub discussions or issues are best for organization.
We’ve also created a Matrix/Element space with a number of different channels for more general discussion: #breezy-weather-space:matrix.org.
- If you are not comfortable writing a GitHub discussion/issue in English, you can ask on the channel if someone can help you in your language.
  - We also have a dedicated help channel in French: #breezy-weather-francais:matrix.org
- If you’d prefer a direct channel link instead of a space link, here’s the main Breezy Weather Matrix channel: #breezy-weather:matrix.org

📜 License

GNU Lesser General Public License v3.0
This License does not grant any rights in the trademarks, service marks, or logos of any Contributor.
Misrepresentation of the origin of that material is prohibited, and modified versions of such material must be marked in reasonable ways as different from the original version.

Before creating a fork, check if the intent action nodomain.freeyourgadget.gadgetbridge.ACTION_GENERIC_WEATHER can cover your need (for example, you want to re-use our weather data in your own customized widget). It can be enabled from Settings > Widgets & Live Wallpaper > Data sharing. You can also help testing our ContentProvider exposing the full weather data of Breezy Weather.

Otherwise, remember to:

Respect the project’s LICENSE
Avoid confusion with the Breezy Weather app:
- Do NOT use the breezy flag when compiling releases you plan to distribute
- Change the app name in res_fork/values/strings.xml
- Change the app icons in the res_fork folders
- Avoid installation conflicts: change the applicationId in build.gradle.kts

butzist/ActivityLauncher

Activity launcher creates shortcuts for any installed app and hidden activities to launch them with ease

Activity Launcher

Launches hidden activities and creates shortcuts for installed apps

Shortcuts not created

In case the shortcuts are not created in your home screen, make sure Activity Launcher has the "Home screen shortcuts" permission.

Click on Settings -> Apps -> Manage apps -> Activity Launcher -> Other permissions -> Home screen shortcuts.

See #267.

Translations

Translations can be updated via Pull Requests on GitHub. Feel free to contribute by submitting PRs to improve or add translations.

SagerNet/sing-box-for-android

Experimental Android client for sing-box

SFA

Experimental Android client for sing-box, the universal proxy platform.

Documentation

https://sing-box.sagernet.org/installation/clients/sfa/

License

Copyright (C) 2022 by nekohasekai <contact-sagernet@sekai.icu>

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.

In addition, no derivative work may use the name or imply association
with this application without prior consent.

Under the license, that forks of the app are not allowed to be listed on F-Droid or other app stores under the original name.

LanRhyme/MicYou

MicYou is a powerful tool that turns your Android device into a high-quality wireless microphone for your PC.

MicYou

简体中文 | 繁體中文 | English

Support Me

MicYou is a powerful tool that turns your Android device into a high-quality microphone for your PC. Built with Kotlin Multiplatform and Jetpack Compose/Material 3.

Features

Multiple Connection Modes: Support for Wi-Fi and USB (ADB/AOA).
Audio Processing: Built-in Noise Suppression, Auto Gain Control (AGC), and Dereverberation.
Cross-Platform:
- Android Client: Modern Material 3 interface, dark/light theme support.
- Desktop Server: Receive audio on Windows/Linux/macOS.
Virtual Microphone: Works seamlessly with VB-Cable/BlackHole to act as a system microphone input.
Customizable: Adjust sample rate, channel count, and audio format.

Screenshots

Android App

Main Screen	Settings

Desktop App

Getting Started

Quick start and platform-specific setup instructions are now in the FAQ:

Contributing

We welcome contributions of all kinds! Whether you want to report a bug, suggest a feature, help with translations, or contribute code, please check our Contributing Guidelines to get started.

Contributors

Made with contrib.rocks.

Star History

Acknowledgments

Special thanks to CQU Open Source Software Mirror for providing a mirror download service for this project.

Special thanks to MirrorChyan for providing a high-speed mirror download service for ths project.

Special thanks to all the contributors for helping to make the project even better.

keiyoushi/extensions-source

Source code of extensions in https://github.com/keiyoushi/extensions

Keiyoushi Extensions

Please give the repo a ⭐

Build	Need Help?

Usage

If you are new to repository/extensions, please read the Keiyoushi Getting Started guide first.

You can add our repo by visiting the Keiyoushi Website
Otherwise, copy & paste the following URL: https://raw.githubusercontent.com/keiyoushi/extensions/repo/index.min.json

Requests

To request a new source or bug fix, create an issue.

Please note that creating an issue does not mean that the source will be added or fixed in a timely fashion, because the work is volunteer-based. Some sources may also be impossible to do or prohibitively difficult to maintain.

If you would like to see a request fulfilled and have the necessary skills to do so, consider contributing! Issues are up-for-grabs for any developer if there is no assigned user already.

Contributing

Contributions are welcome!

Check out the repo's issue backlog for source requests and bug reports.

License

Copyright 2015 Javier Tomás

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

Disclaimer

This project does not have any affiliation with the content providers available.

This project is not affiliated with Mihon/Tachiyomi. Don't ask for help about these extensions at the official support means of Mihon/Tachiyomi. All credits to the codebase goes to the original contributors.

JetBrains/kotlin

The Kotlin Programming Language.

Kotlin Programming Language

Welcome to Kotlin!
Kotlin is a concise multiplatform language developed by JetBrains and contributors.

Some handy links:

Kotlin Multiplatform capabilities

Support for multiplatform programming is one of Kotlin’s key benefits. It reduces time spent writing and maintaining the same code for different platforms while retaining the flexibility and benefits of native programming.

Kotlin Multiplatform and Compose Multiplatform for sharing business logic and UI between Android, iOS, desktop, and web.
Get started with Kotlin Multiplatform
Kotlin Multiplatform Benefits
Share code on all platforms
Share code on similar platforms

Editing Kotlin

Build environment requirements

This repository is using Gradle toolchains feature to select and auto-provision required JDKs from Eclipse Adoptium project.

Alternatively, it is still possible to only provide required JDKs via environment variables (see gradle.properties for supported variable names). To ensure Gradle uses only JDKs from environmental variables - disable Gradle toolchain auto-detection by passing -Porg.gradle.java.installations.auto-detect=false option (or put it into $GRADLE_USER_HOME/gradle.properties).

On Windows you might need to add long paths setting to the repo:

git config core.longpaths true

Building

The project is built with Gradle. Run Gradle to build the project and to run the tests using the following command on Unix/macOS:

./gradlew <tasks-and-options>

or the following command on Windows:

gradlew <tasks-and-options>

On the first project configuration gradle will download and setup the dependencies on:

intellij-core is a part of command line compiler and contains only necessary APIs.
idea-full is a full blown IntelliJ IDEA Community Edition to be used in the plugin module.

These dependencies are quite large, so depending on the quality of your internet connection you might face timeouts getting them. In this case, you can increase timeout by specifying the following command line parameters on the first run:

./gradlew -Dhttp.socketTimeout=60000 -Dhttp.connectionTimeout=60000

Important gradle tasks

clean - clean build results
dist - assembles the compiler distribution into dist/kotlinc/ folder
install - build and install all public artifacts into local maven repository
coreLibsTest - build and run stdlib, reflect and kotlin-test tests
gradlePluginTest - build and run gradle plugin tests
compilerTest - build and run all compiler tests

To reproduce TeamCity build use -Pteamcity=true flag. Local builds don't run proguard and have jar compression disabled by default.

OPTIONAL: Some artifacts, mainly Maven plugin ones, are built separately with Maven. Refer to libraries/ReadMe.md for details.

To build Kotlin/Native, see kotlin-native/README.md.

Working with the project in IntelliJ IDEA

It is recommended to use the latest released version of Intellij IDEA (Community or Ultimate Edition). You can download IntelliJ IDEA here.

After cloning the project, import the project in IntelliJ by choosing the project directory in the Open project dialog.

For handy work with compiler tests it's recommended to use Kotlin Compiler Test Helper.

Dependency verification

We have a dependencies verification feature enabled in the repository for all Gradle builds. Gradle will check hashes (md5 and sha256) of used dependencies and will fail builds with Dependency verification failed errors when local artifacts are absent or have different hashes listed in the verification-metadata.xml file.

It's expected that verification-metadata.xml should only be updated with the commits that modify the build. There are some tips how to perform such updates:

Delete components section of verification-metadata.xml to avoid stockpiling of old unused dependencies. You may use the following command:

#macOS
sed -i '' -e '/<components>/,/<\/components>/d' gradle/verification-metadata.xml
#Linux & Git for Windows
sed -i -e '/<components>/,/<\/components>/d' gradle/verification-metadata.xml

Re-generate dependencies with Gradle's --write-verification-metadata command (verify update relates to your changes)

./gradlew --write-verification-metadata sha256 -Pkotlin.native.enabled=true resolveDependencies

resolveDependencies task resolves dependencies for all platforms including dependencies downloaded by plugins.

You can also use ./scripts/update-verification-metadata.sh script which includes both of these steps

Keep in mind:

If you’re adding a dependency with OS mentioned in an artifact name (darwin, mac, osx, linux, windows), remember to add them to implicitDependencies configuration or update resolveDependencies task if needed. resolveDependencies should resolve all dependencies including dependencies for different platforms.
If you have a local.properties file in your Kotlin project folder, make sure that it doesn't contain kotlin.native.enabled=false. Otherwise, native-only dependencies may not be added to the verification metadata. This is because local.properties has higher precedence than the -Pkotlin.native.enabled=true specified in the Gradle command.

Using -dev versions

We publish -dev versions frequently.

For -dev versions you can use the list of available versions and include this maven repository:

maven("https://redirector.kotlinlang.org/maven/bootstrap")

License

Kotlin is distributed under the terms of the Apache License (Version 2.0). See license folder for details.

Contributing

Please be sure to review Kotlin's contributing guidelines to learn how to help the project.

Kotlin Foundation

The Kotlin Foundation is a non-profit organization whose mission is to promote and advance the Kotlin ecosystem. You can learn more about the structure and goals of the Kotlin Foundation on its official website.

home-assistant/android

Home Assistant Companion for Android

Welcome to the Home Assistant Companion for Android! This is the official Android app for Home Assistant, a powerful open-source home automation platform. Join us in building an app used by millions of users worldwide.

Features

Control Your Smart Home: Seamlessly interact with your Home Assistant instance.
Native Android Experience: Leverage Android-specific features like widgets, notifications, and location tracking.
Customizable: Tailor the app to your needs with themes, dashboards, and more.
Open Source: Contribute to a project that empowers users to take control of their smart homes.

Get the app

Download from the Play Store
Join the Play Store Beta to test new features early.
Other Stores: The app is also available in other app stores.

Documentation

Looking for help? Check out the Home Assistant Companion Documentation for detailed guides on using the app.

Report a bug or request a feature

Found a bug or have an idea for a new feature? Let us know!

Open a Bug Report
Request a Feature

We appreciate your feedback and contributions to make the app even better!

Contributing

We are thrilled to welcome contributions from the community! This app exists thanks to the incredible efforts of the Home Assistant community. Whether you're fixing bugs, adding new features, or improving documentation, your contributions make a difference.

Every contribution, big or small, is greatly appreciated. Together, we can make the Home Assistant Companion for Android even better!

Getting started

Read the Developer Guide.
Fork the repository and create a branch for your changes.
Submit a pull request and join the discussion!

Join the community

Connect with other contributors and users in our vibrant Discord Community: Join the #Android channel to chat with developers and contributors.

Star the repository

If you find this project useful, consider giving it a star on GitHub!
It helps others discover the project and motivates us to keep improving.

xororz/local-dream

Run Stable Diffusion on Android Devices with Snapdragon NPU acceleration. Also supports CPU/GPU inference.

Local Dream

Android Stable Diffusion with Snapdragon NPU acceleration
Also supports CPU/GPU inference

About this Repo

This project is now open sourced and completely free. Hope you enjoy it!

If you like it, please consider sponsor this project.

Note

Currently focused on SD1.5 and SDXL models. SD2.1 is no longer maintained due to poor quality and limited popularity.

NPU support:

SD1.5 models are supported on Snapdragon NPUs with Hexagon V68 architecture or newer.
SDXL models are supported on Snapdragon 8 Gen 3 and newer devices.

If your chip is outside the above scope, you can only run SD1.5 on CPU/GPU.

You can join our telegram group for discussion or help with testing.

User Guide

For certain reasons, all guides and documentation have been moved to Guide Site.

Credits & Acknowledgments

Local Dream is built on top of many excellent open-source projects. Sincere thanks to all the authors and contributors whose work made this project possible.

C++ Libraries

Qualcomm QNN SDK - NPU model execution
alibaba/MNN - CPU model execution
xtensor-stack - Tensor operations & scheduling
mlc-ai/tokenizers-cpp - Text tokenization
yhirose/cpp-httplib - HTTP server
nothings/stb - Image processing
facebook/zstd - Model compression
nlohmann/json - JSON processing

Android Libraries

square/okhttp - HTTP client
coil-kt/coil - Image loading & processing
MoyuruAizawa/Cropify - Image cropping
AOSP, Material Design, Jetpack Compose - UI framework

Models

CompVis/stable-diffusion and all other model creators
xinntao/Real-ESRGAN - Image upscaling
Kim2091/UltraSharpV2 - Image upscaling
bhky/opennsfw2 - NSFW content filtering

💖 Support This Project

If you find Local Dream useful, please consider supporting its development:

What Your Support Helps With:

Additional Models - More AI model integrations
New Features - Enhanced functionality and capabilities
Bug Fixes - Continuous improvement and maintenance

Your sponsorship helps maintain and improve Local Dream for everyone!

SimonSchubert/Kai

OpenClaw alternative in your pocket

Kai 9000

An open-source AI assistant with persistent memory that runs on Android, iOS, Windows, Mac, Linux, and Web.

Website - Documentation

Installation

Homebrew (macOS):

brew install --cask simonschubert/tap/kai

AUR (Arch Linux):

yay -S kai-bin

Winget (Windows):

winget install SimonSchubert.Kai

Direct Downloads

Platform	Format	Download
Android	APK	GitHub Releases
macOS	DMG	GitHub Releases
Windows	MSI	GitHub Releases
Linux	DEB	GitHub Releases
Linux	RPM	GitHub Releases
Linux	AppImage	GitHub Releases

AI That Builds Screens, Not Just Text

Kai 9000's Interactive UI lets the AI generate full interactive screens — quizzes, dashboards, recipes, brainstorms, and more. Navigate by tapping buttons instead of scrolling through chat.

Features

Persistent memory — Kai remembers important details across conversations and uses them automatically
Customizable soul — Define the AI's personality and behavior with an editable system prompt
Multi-service fallback — 24 LLM providers with automatic failover
On-device inference — Run AI models locally on Android using LiteRT, no internet needed
Tool execution — Web search, notifications, calendar events, shell commands, and more
MCP server support — Connect to remote tool servers via the Model Context Protocol
Autonomous heartbeat — Periodic self-checks that surface anything needing attention
Settings export/import — Backup and restore all settings as a JSON file
Encrypted storage — Conversations stored locally with encryption
Text to speech — Listen to AI responses
Linux Sandbox — On Android, the AI can run shell commands, scripts, and tools in a secure sandboxed Linux environment
Image attachments — Attach images to any conversation

Linux Sandbox (Android)

On Android, Kai includes a built-in Linux environment that the AI can use to execute shell commands, run scripts, and operate tools on your behalf. This turns Kai from a chat-only assistant into one that can take real action — installing packages, processing data, running Python scripts, and more.

Powered by Alpine Linux — A lightweight ~3 MB download sets up a full Linux userland via proot, no root required
Optional packages — One tap installs bash, curl, wget, git, jq, python3, pip, and Node.js
Interactive terminal — A built-in terminal lets you run commands manually alongside the AI
Secure — Everything runs sandboxed inside the app with no access to the host system

Enable it in Settings > Linux Sandbox.

Screenshots

Desktop

Web

Mobile

How It Works

                        ┌────────┐
                        │  User  │
                        └───┬────┘
                            │ message
                            ▼
               ┌─────────────────────────┐
               │          Chat           │
               │                         │
               │  prompt + memories      │
               │        │                │
               │        ▼                │
               │    ┌────────┐           │
               │    │   AI   │◀─┐        │
               │    └───┬────┘  │        │
               │        │   tool calls   │
               │        │   & results    │
               │        ▼      │        │
               │    ┌────────┐ │        │
               │    │ Tools  │─┘        │
               │    └───┬────┘          │
               │        │               │
               └────────┼───────────────┘
                        │ store / recall
                        ▼
               ┌─────────────────┐    hitCount >= 5
               │     Memory      │───────────────────┐
               │                 │                   │
               │  facts, prefs,  │                   ▼
               │  learnings      │          ┌────────────────┐
               │                 │◀─delete──│ Promote into   │
               └─────────────────┘          │ System Prompt  │
                        ▲                   └────────────────┘
                        │ reviews
                        │
               ┌─────────────────┐
               │    Heartbeat    │
               │                 │
               │  autonomous     │
               │  self-check     │
               │  every 30 min   │
               │  (8am–10pm)     │
               │                 │
               │  all good?      │
               │  → stays silent │
               │  needs action?  │
               │  → notifies user│
               └─────────────────┘

Chat — User sends a message. The AI responds, calling tools (memory, web search, shell, etc.) in a loop until it has a final answer.
Memory — The AI stores and recalls facts, preferences, and learnings. Memories that prove useful (5+ hits) can be promoted into the system prompt permanently.
Heartbeat — A background self-check runs every 30 minutes. It reviews memories, pending tasks, and emails. If something needs attention, it notifies the user. Otherwise, it stays silent.

Supported Services

Anthropic · OpenAI · Gemini · DeepSeek · Mistral · xAI · OpenRouter · Groq · NVIDIA · Cerebras · Ollama Cloud · LongCat · Together AI · Hugging Face · Venice AI · Moonshot AI · Z.AI · MiniMax · AIHubMix · Deep Infra · Fireworks AI · OpenCode · OpenAI-Compatible API · LiteRT On-Device (Android) · Free tier (no API key needed)

MCP Servers

Kai supports the Model Context Protocol for connecting to external tool servers. Go to Settings > Tools > Add MCP Server to connect to any Streamable HTTP MCP endpoint, or pick from a curated list of popular free servers:

Server	Description
Fetch	Fetch web content and convert HTML to markdown
DeepWiki	AI-powered docs for any GitHub repo
Sequential Thinking	Structured step-by-step problem-solving
Context7	Up-to-date library and framework docs
Globalping	Ping, traceroute, DNS from global probes
CoinGecko	Real-time crypto prices and market data
Manifold Markets	Prediction market data and odds
Find-A-Domain	Domain availability across 1,444+ TLDs

All popular servers are free and require no API key. MCP servers auto-reconnect on app startup.

Integrations

Splinterlands Auto-Battle (Android & Desktop)

Kai can automatically play Splinterlands Wild Ranked battles. Configure one or more LLM services in priority order, add your Hive account, and hit Start -- Kai will continuously find matches, pick teams using LLM-powered strategy, and submit them on-chain. Falls back to a simple greedy picker if all LLM services fail. Available in Settings > Integrations.

Supported Languages

Afrikaans, Albanian, Amharic, Arabic, Belarusian, Bengali, Bulgarian, Chinese (Simplified), Chinese (Traditional), Croatian, Czech, Danish, Dutch, English, Estonian, Filipino, Finnish, French, German, Greek, Gujarati, Hebrew, Hindi, Hungarian, Indonesian, Italian, Japanese, Kazakh, Korean, Latvian, Lithuanian, Malay, Marathi, Norwegian, Persian, Polish, Portuguese, Punjabi, Romanian, Romansh, Russian, Serbian, Slovak, Slovenian, Spanish, Swahili, Swedish, Tamil, Telugu, Thai, Turkish, Ukrainian, Urdu, Vietnamese, Zulu

Contributing

Screenshot Automation

Two separate screenshot pipelines exist, both using Compose screenshot tests:

README screenshots — Used for this README. CI runs this automatically on every push and auto-commits any changes.

./gradlew :screenshotTests:updateScreenshots

Store screenshots — Generates localized screenshots for the Play Store in all supported locales. Upload via fastlane.

./gradlew :screenshotTests:generateStoreScreenshots
bundle exec fastlane android upload_screenshots

Kai UI component screenshots — Records golden images for KaiUiScreenshotTest only. Faster than recording the full suite when iterating on Kai UI components.

./gradlew :screenshotTests:recordKaiUiScreenshots

Credits

Mistral: https://mistral.ai/

six2dez/burp-ai-agent

Burp Suite extension that adds built-in MCP tooling, AI-assisted analysis, privacy controls, passive and active scanning and more

Burp AI Agent

The bridge between Burp Suite and modern AI.

Burp AI Agent is an extension for Burp Suite that integrates AI into your security workflow. Use local models or cloud providers, connect external AI agents via MCP, and let passive/active scanners find vulnerabilities while you focus on manual testing.

Highlights

10 AI Backends — Burp AI (built-in), Ollama, LM Studio, NVIDIA NIM, Generic OpenAI-compatible, Gemini CLI, Claude CLI, Codex CLI, OpenCode CLI, Copilot CLI.
53+ MCP Tools — Let Claude Desktop (or any MCP client) drive Burp autonomously.
62 Vulnerability Classes — Passive and Active AI scanners across injection, auth, crypto, and more.
Burp Scan Skill — Use your preferred AI coding assistant (Claude Code, Gemini CLI, Codex, etc.) as a scanner via MCP.
3 Privacy Modes — STRICT / BALANCED / OFF. Redact sensitive data before it leaves Burp.
Custom Prompt Library — Save free-form prompts per context (HTTP request or scanner issue); launch them from the right-click menu or type ad-hoc ones via Custom….
Audit Logging — JSONL with SHA-256 integrity hashing for compliance; every launch stamped with promptSource / contextKind for reproducibility.

Quick Start

1. Install

Download the latest JAR from Releases, or build from source (Java 21):

git clone https://github.com/six2dez/burp-ai-agent.git
cd burp-ai-agent
JAVA_HOME=/path/to/jdk-21 ./gradlew clean shadowJar
# Output: build/libs/Custom-AI-Agent-<version>.jar

2. Load into Burp

Open Burp Suite (Community or Professional).
Go to Extensions > Installed > Add.
Select Java as extension type and choose the .jar file.

3. Agent Profiles

The extension auto-installs the bundled profiles into ~/.burp-ai-agent/AGENTS/ on first run. Drop additional *.md files in that directory to add custom profiles.

4. Configure a Backend

Open the AI Agent tab and go to Settings. Pick a backend:

Backend	Type	Setup
Burp AI (built-in)	In-process	Use Burp Suite Pro's built-in AI when available; no extra config required.
Ollama	Local HTTP	Install Ollama, run `ollama serve`, pull a model (`ollama pull llama3.1`).
LM Studio	Local HTTP	Install LM Studio, load a model, start the server.
NVIDIA NIM	HTTP	Use the default `https://integrate.api.nvidia.com` endpoint, set your NVIDIA API key, and choose a model such as `moonshotai/kimi-k2.5`.
Generic OpenAI-compatible	HTTP	Provide a base URL and model for any OpenAI-compatible provider.
Gemini CLI	Cloud CLI	Install `gemini`, run `gemini auth login`.
Claude CLI	Cloud CLI	Install `claude`, set `ANTHROPIC_API_KEY` or run `claude login`.
Codex CLI	Cloud CLI	Install `codex`, set `OPENAI_API_KEY`.
OpenCode CLI	Cloud CLI	Install `opencode`, configure provider credentials.
Copilot CLI	Cloud CLI	Install `copilot` and sign in with your GitHub account.

For NVIDIA NIM, the backend expects the same chat-completions style flow as the NVIDIA hosted endpoint. A working configuration is:

Backend: NVIDIA NIM
Base URL: https://integrate.api.nvidia.com
Model: moonshotai/kimi-k2.5
API Key: <your nvapi token>

Leave extra headers empty unless your gateway requires them. The extension sends requests to /v1/chat/completions and uses the configured bearer token automatically.

5. Run Your First Analysis

Browse a target through Burp Proxy.
Right-click any request in Proxy > HTTP History.
Select Extensions > Burp AI Agent > Analyze this request.
A chat session opens with the AI analysis.

6. Connect Claude Desktop via MCP (Optional)

Enable the MCP server in Settings > MCP Server and add this to your Claude Desktop config:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "burp-ai-agent": {
      "command": "npx",
      "args": [
        "-y",
        "supergateway",
        "--sse",
        "http://127.0.0.1:9876/sse"
      ]
    }
  }
}

Requires Node.js 18+. If you enable External Access, the MCP client must send Authorization: Bearer <token> on every request.

Burp Scan Skill (Terminal AI Scanning)

The burp-scan skill lets you use any AI coding assistant (Claude Code, Gemini CLI, Codex, etc.) as a Burp scanner from your terminal. Instead of the plugin's built-in AI, your terminal AI becomes the reasoning engine while Burp provides the tools via MCP.

What It Contains

53+ MCP tool reference organized by scanning action
Passive analysis protocol (traffic analysis without sending requests)
Active testing payload library (200+ payloads for 62 vuln classes with detection patterns)
End-to-end scanning workflow (scope -> passive -> active -> OOB -> report)
Issue creation protocol with severity/confidence mapping

Install for Claude Code

Copy the skill to your Claude Code skills directory:

# Global (available in all projects)
cp -r skills/burp-scan ~/.claude/skills/burp-scan

# Or project-specific
cp -r skills/burp-scan .claude/skills/burp-scan

Then use /burp-scan in Claude Code or let it trigger automatically when you mention Burp scanning.

Install for Other AI Assistants

The skill is a standalone Markdown file at skills/burp-scan/SKILL.md. You can use it with any AI assistant that supports system prompts or context files:

Gemini CLI / Codex / OpenCode: Add as a context file or paste into your system prompt
Custom MCP clients: Include the skill content as system context alongside your MCP connection
Any LLM: The file is self-contained — feed it as context along with your MCP tool definitions

Usage Example

You: Connect to Burp MCP at localhost:9876 and scan the proxy history for IDOR vulnerabilities

AI: [Uses proxy_http_history to pull traffic]
    [Identifies endpoints with numeric IDs]
    [Sends http1_request with ID+1, ID-1 payloads]
    [Compares responses for different user data]
    [Creates issue_create for confirmed IDOR]

The skill and the plugin's built-in scanner are complementary: the plugin runs automated background scanning, while the skill enables interactive, analyst-guided scanning from your terminal.

Documentation

Full documentation is available at burp-ai-agent.six2dez.com.

Operator Playbooks

Settings are schema-versioned internally (settings.schema.version) and migrated additively on load for safe upgrades.

Requirements

Burp Suite Community or Professional (2023.12+)
Java 21 (bundled with modern Burp for runtime; required separately for building from source)
At least one AI backend configured (see table above)

License

This project is licensed under the MIT License.

Disclaimer

Usage of Burp AI Agent for attacking targets without prior consent is illegal. It is the user's responsibility to obey all applicable laws. The developers assume no liability for misuse or damage caused by this tool. Use responsibly.

Contributing

Issues and pull requests are welcome. See CONTRIBUTING.md for development setup and guidelines, or the Developer docs for architecture details.

libre-tube/LibreTube

An alternative frontend for YouTube, for Android.

Note
We don't accept feature or bug requests on these platforms. Kindly submit requests only on GitHub.

📜️ Credits

_{Readme Design and Banners by XelXen}
_{Readme Screenshots by ARBoyGo}
_{Readme Emoji is from openmoji}

Icons

_{Default App Icon by XelXen}
_{Boosted Bird by Margot Albert-Heuzey}

About

YouTube has an extremely invasive privacy policy which relies on using user data in unethical ways. They store a lot of your personal data - ranging from ideas, music taste, content, political opinions, and much more than you think.

This project is aimed at improving the users' privacy by being independent from Google and bypassing their data collection.

Therefore, the app is using the Piped API, which uses proxies to circumvent Google's data collection and includes some other additional features.

If you have questions or need help, please make sure to read the FAQ before asking for help at the community channels. The Matrix room is considered as the main communication channel, all other forums or social media accounts are maintained by volunteers from the community but not the developer(s).

Screenshots

More screenshots can be found here

Features

Contributing

Whether you have ideas, translations, design changes, code cleaning or really heavy code changes, help is always welcome. The more is done, the better it gets! Please respect our Code of Conduct in order to keep all interactions and discussions healthy.

You can open and build the project like any other normal Android project by using Android Studio.

Please make sure the title of your pull request and the commit messages follow the conventional commit types (e.g. feat: support for xy). For instance, the most common commit types are "feat", "fix", "refactor", "ci" and "chore".

Note

Any issue avoiding the issue template will be ignored and forced to be closed.

Note

The usage of AI to generate issue texts or pull requests is not permitted at this repository and thus such issues / pull requests will be ignored.

Donate

Donations can be made at:

https://github.com/sponsors/Bnyro
https://liberapay.com/Bnyro
Monero (XMR): 47jAx7jMFo5iqy9VgDH98qL1bSK4kr6Pxi7HKWcRwsxbVYJdjxJtyrwXeAUa5MutvcQUmWMBfvAKnPAutDHvWEymUgLm5v8
Ethereum (ETH): 0x599909f54CdC18B997Be8F032341d1Fb14BF4F39

Contributions in any form are welcome!

📝 Translations

Differences to NewPipe

With LibreTube, you have the choice to either send all requests directly to YouTube or proxy them via Piped for better privacy. Piped acts as a middleman server between you and YouTube in this case, which prevents YouTube from accessing personal information such as your IP address. Additionally, using Piped allows you to sync your subscriptions between LibreTube and Piped, which can be used on desktop too.

While LibreTube only supports YouTube, NewPipe also allows the use of other platforms like SoundCloud, PeerTube, Bandcamp and media.ccc.de.
Both are great clients for watching YouTube videos. It depends on the individual's use case which one fits their needs better.

Privacy Policy and Disclaimer

LibreTube aims to protect the privacy of its users. Our Privacy Policy gives detailed information on which data the app stores in order to work, how it is being used, and how the project protects your personal information. It is recommended to read the privacy policy of LibreTube as well as the privacy policy of the instance you have chosen inside the app.

License

LibreTube is Free Software: You can use, study, share and modify it at your will. The app can be redistributed and/or modified under the terms of the GNU General Public License version 3 or later published by the Free Software Foundation.

↥ Scroll to top

GitHub Kotlin Monthly Trending

2dust/v2rayNG

v2rayNG

Telegram Channel

Usage

Geoip and Geosite

More in our wiki

Development guide

bannedbook/fanqiang

翻墙-科学上网、翻墙工具、翻墙教程项目库

Windows V2ray/SS/SSR 翻墙教程

iPhone/iPad/iOS V2ray/SS 翻墙APP教程

Android 安卓翻墙APP教程

Mac翻墙软件教程

路由器翻墙教程

Linux翻墙教程

游戏机翻墙教程

ChromeGo - Chrome一键翻墙包

koiverse/ArchiveTune

ArchiveTune

📸 Showcase

✨ Features

Playback

Audio

Lyrics & Discovery

Sync & Social

Interface

Customization

📥 Download Now

Stable Release

Nightly Build

❓ Need Help or Have Questions?

🌍 Globalization

✨ Project Contributors

🛠️ Development & Engineering

⭐ Support the Project

Tribe

🤝 Acknowledgments

⚖️ Legal Disclaimer

amir1376/ab-download-manager

AB Download Manager

Description

Features

Installation

Download and Install the App

Installation script (Linux)

Winget or Scoop (for Windows)

Homebrew (for macOS & Linux)

Browser Extensions

Screenshots

Project Status & Feedback

Community

Repositories And Source Code

Bug Report

Build From Source

Translations

Contribution

Support the Project

ZalithLauncher/ZalithLauncher2

Zalith Launcher 2

🌐 Language and Translation Support

📦 Build Instructions (For Developers)

Requirements

Build Steps

📜 License

Additional Terms (Pursuant to Section 7 of the GPLv3 License)

Open Source Libraries and Licenses

embabel/embabel-agent

Embabel Agent Framework

Key Concepts

Quick Start

Why Is Embabel Needed?

Show Me The Code

Dog Food Policy

Getting Started

Getting the bits

Environment variables

Services

Running

Example Agents

Track custom operations with `@Tracked`