UGT: Use the GitHub Thing

com.usegithubthingPublished by usegithubthing.comOfficial publisherv0.3.0Updated Nov 5, 2026

Get open-source GitHub projects running on your computer, with your AI app

VerifiedStreamable HTTPWeb executableCloud & InfrastructureDeveloper Tools

Overview

AI-generated overview

UGT (Use the GitHub Thing) helps an AI assistant set up and run open-source GitHub projects on your own computer, using shared setup recipes.

What you can do
  • Find and run setups for a pasted GitHub project link, including the project's own installer or a verified recipe
  • Continue a failed setup in the desktop AI app with the same link and error details
  • Run file jobs and apps in a sandbox and open the resulting file or app address
  • Look up what a recipe runs and what access it declares, and get the install line for UGT
  • Submit a working recipe to the public catalogue as a pull request
When to use it
Useful when you want to actually run an open-source project from GitHub on Windows, Mac or Linux rather than only read its code, especially for tasks like transcription, document conversion, image background removal or video generation.
Requirements
Either the hosted remote endpoint or a local install: a Claude Desktop extension, a shell install script, Homebrew, Scoop or a Go build. On Intel Macs a container engine such as Docker Desktop or OrbStack must be running. No account or API key is declared in the manifest.
Before you install
Projects run in containers and may need the internet, folders, devices, admin prompts, large downloads, accounts, keys or paid cloud compute; UGT says it asks first. Recipes from outside the catalogue ask before reaching beyond the sandbox. Submitting a recipe opens a pull request as you and must be free of personal files, paths and keys. Run reports are sent only with your agreement.

Installation

In SourceWeft

  1. Open UGT: Use the GitHub Thing in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/com.usegithubthing%2Fugt/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

{
  "mcpServers": {
    "ugt-use-the-github-thing": {
      "type": "http",
      "url": "https://mcp.usegithubthing.com/mcp"
    }
  }
}

README

[ugt: Use the GitHub Thing]

You found it on GitHub. Now use it.

Paste the GitHub link to the project you want to use.
UGT helps get it working on your computer and shows you how to use it again.
Free and open source. Windows, Mac and Linux.

[CI] [Go Reference] [Release] [License: Apache-2.0]

How it works · Get started · What you can do · Why not just ask your agent? · The catalogue · Share your recipe · House rules


How it works

  1. Start with the GitHub link. You can also add an error you ran into or something you want to do with the project.
  2. Follow the setup for your computer. UGT looks for a ready setup or the project's own installer. If it needs a closer look, your AI app continues with the same link and details. A recipe is a setup someone has already checked; your agent can make one when the project has none.
  3. Use what it made. Open the resulting file or app. File jobs check their output, and apps keep their saved data when you stop and reopen them. If a run fails, ask for help with that run without starting the conversation over.
  4. Share it, if you like. Once it works, UGT can submit your recipe to the catalogue, so the next person gets it fast.

Get started

Paste your GitHub project into UGT. The link is enough. If you already tried to install it, you can include the error you saw.

UGT checks for a way to use that project on your computer. If it offers Open in UGT, open it, choose your file if it needs one, and run it. When a file is ready, UGT shows you its folder. An app opens at its own address.

If the project needs a closer look, continue in your desktop AI app. The website carries your link and notes into the project message. If UGT needs installing, it shows how to set it up. UGT has no subscription; your AI app's own usage limits and pricing still apply.

Set up UGT yourself
  • Claude Desktop: install the UGT desktop extension for your computer. The project page helps you pick the download.
  • On a Mac or Linux: open Terminal and run curl -fsSL https://usegithubthing.com/install | sh.
  • On Windows: open PowerShell and run irm https://usegithubthing.com/install.ps1 | iex. Windows may ask for permission and a restart.

Return to your project when setup finishes. On an Intel Mac, start Docker Desktop, OrbStack or Docker Engine first.

For developers
WhereHow
Windowsscoop bucket add auscaster https://github.com/auscaster/scoop-bucket, then scoop install ugtToday
Windowswinget install auscaster.ugtNext
macOS or Linuxbrew install auscaster/tap/ugtToday
Linuxcurl -fsSL https://usegithubthing.com/install | shToday
Any MCP clientcom.usegithubthing/ugt in the MCP Registry, or ugt mcp over stdioToday
Any AI app, with nothing installedThe hosted MCP server https://mcp.usegithubthing.com/mcp: it finds how UGT runs a project, shows what a recipe runs and reaches, and gives the line that installs UGTToday
Claude Code, Codex, Gemini CLIUGT's plugin: claude plugin install ugt@auscaster after claude plugin marketplace add auscaster/agent-plugins, the same for Codex, or gemini extensions install https://github.com/auscaster/ugtToday
Your browserA "Use it" button on every GitHub repositoryNext
From source, any OSgo install github.com/auscaster/ugt/cmd/ugt@latest, then ugt setup and ugt connectToday

What you can do with it

GitHub is the world's biggest shelf of free software, and most of it never reaches the people it could help, because it ships as code, not as an app. UGT turns any of it into something you can just ask for.

Ask your agentWhat runs
"Put subtitles on this interview"openai/whisper: speech to text, fully offline. Verified recipe
"Turn my HTML into a four-second intro video"heygen-com/hyperframes: a headless browser and ffmpeg. Verified recipe
"Design a wall hook I can 3D print"earthtojake/text-to-cad: an industrial CAD kernel. Verified recipe
"Save these pages as clean Markdown, on my own computer"firecrawl/firecrawl: a five-service crawler stack. Verified recipe
"Cut the background out of this photo"danielgatis/rembg: an image segmentation model
"Convert this PDF and Word file to Markdown"microsoft/markitdown: Microsoft's document converter
"Read this paragraph aloud"debpalash/VoiceStudio: local text to speech
"List the functions in this program"NationalSecurityAgency/ghidra: the NSA's reverse-engineering suite, headless

A few featured examples. You never need a recipe from the catalogue: without one, your agent works the project out the first time. A recipe just makes it faster, because someone already did.

Why not just ask your agent?

Your agent can read the code. It usually can't run it for you, and it starts from zero every time.

  • Most of GitHub assumes Linux. On Windows and on a Mac your agent hits a wall. UGT brings its own private Linux engine, set up in one step, on Linux too: no Docker Desktop, no account, nothing to learn. On an Intel Mac it drives the engine you already have.
  • Proven once, quick for everyone after. The first agent to get a project working can spend an hour building and fixing: memory limits, wrong-architecture binaries, missing system libraries, a resolver that cannot find the internet. The recipe it leaves behind turns the next person's run into a download.
  • Proof, not "it started". A container starting is not your job done. Every recipe carries a check that fails unless the output is real: subtitles that fit the recording, a video of the length you asked for, a mesh you can actually print.
  • Your machine, your files. Projects run in a sandbox with only the files and access their recipe declares. The catalogue reviews that access before admitting a recipe; UGT asks before a locally made recipe reaches beyond its ordinary sandbox. Cloud compute requires your agreement and a stated cost.

The catalogue

Recipes are a shortcut, never a requirement. Each one is a project someone already got doing a job, shared so nobody has to work it out again. A recipe is a folder anyone can read, in recipes/: a compose.yaml that holds everything that runs, and a recipe.json that says what it does. One project can have many recipes, one per job.

Browse them at usegithubthing.com/recipes, or read their source in recipes/. Every one was verified on clean machines before it was admitted, and a new recipe works for everyone the moment it lands, with no update to UGT.

Verified means every service ran as written on clean amd64 and arm64 machines and passed both checks, and both checks rejected deliberately broken outputs. A featured recipe's image is the one that was verified; any other builds on your machine from the same pinned commit and bases.

What's inside a recipe
text
recipes/openai/whisper/subtitles/  compose.yaml    everything that runs: build, limits, mounts, network, and the four services  recipe.json     what it is: project, commit, task, settings, the access it needs, licence  Dockerfile      fetches the pinned source itself, so the build needs no clone  check/          the check scripts
ServiceDoes
taskYour job, on your files
checkFails unless the job really happened, whatever your input was
samplePuts a known input in place
sample-checkFails unless the known input gave the known answer

It is plain Compose, so there is no new language to learn, and every recipe runs anywhere Compose does. The recipe reference has the rules.

Share your recipe

Got a project doing something useful? Share it, so the next person gets it fast instead of working it out again.

Tell your AI "Use the GitHub Thing: share this recipe", or run ugt recipe submit. UGT checks it runs again from scratch, makes sure nothing personal goes with it (your files, paths and keys), and opens a pull request as you. It is then verified on clean machines with no secrets available, and admitted once it passes; a maintainer reviews any recipe that reaches beyond its sandbox first.

Coming with the UGT app. Until then, from the source:

bash
go install github.com/auscaster/ugt/cmd/ugt@latestugt recipe new <owner>/<repo> <task>     # start one, or adopt the project's own Compose fileugt recipe verify <folder>               # until it passesugt login                                # once: approve a code in your browserugt recipe submit <folder>               # opens the pull request as you

ugt recipe submit --dry-run shows exactly what would be sent first. CONTRIBUTING.md and the catalogue rules have the details.

Maintain a project? A "Run with UGT" badge is on the way: put it in your README, and one click opens your project in UGT.

House rules

  • Your files stay yours. Inputs are copied in. Your home folder, keys and the container engine are never handed to a project unless its recipe says why and a maintainer reviewed it, or you agree.
  • Run anything, hide nothing. A recipe can need the internet, a folder, a device or more. It declares each one, and UGT refuses anything it did not declare. A maintainer reviews it before the catalogue admits it; a recipe from anywhere else asks you before it reaches your computer.
  • Proof or it didn't happen. No check, no success.
  • You decide. Installs, admin prompts, big downloads, accounts, keys and cloud compute are always your call, asked plainly before they happen.
  • Secrets never pass through your agent. UGT asks you for them itself, once, and they live in your system keychain.
  • Credit travels with the code. Every recipe records its project's licence, and files adapted from upstream keep theirs.
  • Your files never leave your computer. UGT asks its catalogue which recipes a project has, downloads what a recipe needs, and sends run reports only if you agree: which recipe ran and how it went, never your files, paths or output. The privacy policy has the rest.

License

Apache-2.0. Each packaged project keeps its own licence. The UGT name and logo are not licensed; see NOTICE. Security issues go to SECURITY.md.


[Image]
Made by auscaster

Source: README.md at commit 731bfbe

Tools

0
SourceWeft has not read this server's tools yet.

Version history

3
  1. v0.3.0LatestNov 5, 2026
  2. v0.2.2Nov 4, 2026
  3. v0.2.1Nov 3, 2026

Score

50% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts

    Keep the endpoint answering the MCP handshake; SourceWeft probes it every 30 days.

  • Auth declaredRequired10 pts

    Declare the credential headers in the registry entry, or keep the endpoint answering the probe so its auth can be classified.

  • Tools listed15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts