Skip to main content

goome

🐍 python-goome 🐍

Overlays on top of everything, normal desktop apps, or ui inside your game, straight from Python.

Python 3.8+ PyPI ctypes, no deps Linux Windows macOS GPL-3.0

Docs  ·  Builder  ·  Examples  ·  C  ·  C#  ·  Java  ·  Godot

To see what goome can do, grab one of the ready made apps, like the HUD or the crosshair. To start your own, goome new my-app --lang python from goome-cli makes it from a template.
Questions go in Discussions. If you want to help, the good first issues are small ones to start with.

This is goome for Python. Draw over the whole screen and clicks only stop where you drew something.
It does app windows and pygame style offscreen frames too. It's plain ctypes on top of the C library, nothing to compile.
The builder lets you drag a ui together in your browser and hands you the Python for it.

Do you like this project? If so, please let me know! Discord

ui demo on gnome
a notes app, a stream overlay and a mod menu, running on my gnome desktop. the desktop behind the overlays still works

🫥 An overlay on top of everything 🫥

import goome

with goome.open("my overlay") as g:
    running = True
    while running:
        for ev in g.events(16):
            if ev.type == goome.QUIT:
                running = False
        with g.frame(0) as c:
            if c:
                c.round_rect(100, 100, 220, 60, 12, 0xE0202838)
                c.text(118, 120, "im on top of everything", 0xFFFFFFFF)
                c.hit(100, 100, 220, 60)

🪟 A normal app 🪟

import goome

app = goome.App("My app", 960, 640)
name = ""

@app.frame
def draw(ui):
    global name
    name = ui.input("Name", name)
    if ui.button("Say hi"):
        ui.toast("hi %s" % name)

app.run()

🎮 Inside a game engine 🎮

import goome

g = goome.open_offscreen(800, 600)
ui = g.ui()
win, volume = goome.Window(20, 20, 260), 0.5
while True:
    g.push(goome.MOTION, x=mouse_x, y=mouse_y)   # your engines input goes in
    for ev in g.events(0):
        ui.feed(ev)
    with ui.frame(0):
        with ui.window("Settings", win):
            volume = ui.slider("Volume", volume)
    frame = g.last_frame()                         # premultiplied BGRA pixels come out
    upload_texture(frame.pixels, frame.w, frame.h)

Overlay is still the default, nothing changes unless you ask for an app or offscreen. Theres a whole pygame version of the last one in examples/pygame_embed.py.
Python cant really get inside a game for mods, the other bindings do that part. c-goome has the DirectX 9/11/12 and Vulkan backends plus Metal and GL, csharp-goome has Unity mod templates, java-goome does Fabric and NeoForge, and godot-goome is a GDExtension.

⬇️ Install ⬇️
pip install goome

Its on PyPI. The wheels for Linux x64, Windows x64 and both kinds of Mac already have the goome library inside, so nothing gets built.

Anywhere else pip builds the library from the sdist with your C compiler, a few seconds and only once. If you don't have one, on Debian/Ubuntu its sudo apt install build-essential, on Mac xcode-select --install, on Windows mingw-w64 gcc or Visual Studio (run it from the developer prompt). CC picks a different one.

📦 Other Versions

pip install goome==0.5.1

PyPI has 0.4.0 and up. Older ones, or the newest code on dev, come from git with the tag after an @:

pip install git+https://github.com/goome-ui/python-goome@v0.2.0
pip install git+https://github.com/goome-ui/python-goome@dev

Every version is on the releases page.

Working from a clone instead:

git clone https://github.com/goome-ui/python-goome
cd python-goome
./build.sh test      # builds goome/_native/libgoome.so and runs the tests

If you have your own libgoome somewhere, set GOOME_LIB=/path/to/libgoome.so and it uses that one.

🚀 Quick Start 🚀

A whole overlay that draws a box and prints clicks on it:

import goome

with goome.open("my overlay") as g:
    pace = goome.Pacer(60)
    running = True
    while running:
        for ev in g.events(pace.wait()):
            if ev.type == goome.QUIT:
                running = False
            if ev.type == goome.DOWN:
                print("clicked at %.0f,%.0f" % (ev.x, ev.y))

        with g.frame(0) as c:  # monitor 0, None when theres nothing to draw on
            if c is None:
                continue
            c.round_rect(100, 100, 200, 80, 12, 0xE0202838)
            c.text(116, 128, "click me", 0xFFFFFFFF, big=True)
            c.hit(100, 100, 200, 80)  # only this part takes clicks

Colors are plain 0xAARRGGBB ints and every position is in logical desktop coords, same as in C.

🎛️ UI Kit 🎛️

The immediate mode ui works like in C, except widgets dont take pointers, they hand you the new value back. You keep your own variables and call the widgets every frame.

import goome

with goome.open("settings", no_capture=True) as g, g.ui() as ui:
    win = goome.Window(40, 40, 300)  # h 0 = fit the content
    logo = goome.Bitmap.load("logo.png")
    volume, muted, name = 0.5, False, "goome"
    running = True
    while running:
        for ev in g.events(16):
            if ev.type == goome.QUIT:
                running = False
            ui.feed(ev)
        with ui.frame(0) as c:
            if c is None:
                continue
            with ui.window("Settings", win, goome.WIN_MOVE | goome.WIN_COLLAPSE) as shown:
                if shown:
                    ui.image(logo, 64, 64, 12)
                    if ui.button("Say hi"):
                        print("hi")
                    volume = ui.slider("Volume", volume, 0, 1, "%.2f")
                    muted = ui.toggle("Muted", muted)
                    name = ui.input("Name", name)
    logo.close()

ui.changed tells you if the last widget changed its value this frame, like the int the C functions return.
goome.Window keeps a windows spot and size between frames, and if its open. Set win.open = False to hide it, WIN_CLOSE gives it an x that does the same.
ui.window, ui.scroll_begin and ui.id work with with so the matching end always gets called. You can also just use them in an if and call window_end() / scroll_end() / pop_id() yourself.

Everything else that has a begin and an end works with with too (app / menubar / menu / context / popup / modal / tree / table / split). The end only gets called when C wants it, so with ui.menu("File") as shown: always works, just check shown before you draw the items.
Things C flips for you (a modal being open, a checked menu item, a tree node) take a goome.Flag, and goome.Split(0.3) keeps where a split bar is. vertical=True stacks the panes top and bottom.

with ui.table("files", 3, 200, goome.TABLE_SORTABLE | goome.TABLE_STRIPES) as t:
    t.column("Name")
    t.column("Size", 80)
    t.column("Kind")
    changed, col, desc = t.sort()
    for f in sorted(files, key=lambda f: (f.name, f.size, f.kind)[col], reverse=desc):
        t.row()
        ui.label(f.name)
        t.next()
        ui.label(f.size)
        t.next()
        ui.label(f.kind)

with ui.split("main", side) as panes:
    ui.label("left")
    panes.next()
    text = ui.text_edit("body", text, 0, goome.EDIT_LINE_NUMBERS | goome.EDIT_WRAP)   # h 0 = fill the rest

with ui.scroll_begin("log", 200):
    for i in ui.list_clip(len(lines)):     # only the rows you can see
        ui.label(lines[i])

ui.plot_lines("fps", fps_history)            # a list, array("f") or numpy array
speed = ui.drag_float("Speed", speed, 0.1, 0, 10)
price = ui.number("Price", price, 0.01, "%.2f")
if ui.link("open the docs"):
    ...
ui.toast("saved")

ui.drag_source(type, data) / ui.drop_target(type) drag bytes between widgets, ui.list_clip(count) gives you a range of the rows worth drawing in a long list, ui.focused / ui.set_focus() are keyboard focus, plus theres spinner, badge, context and popup_open / popup_close.
text_edit keeps its own cursor and selection between frames (undo too), you just pass the text in and take it back out like with input.
ui.input_ex(label, text, flags, hint) is input with INPUT_PASSWORD, INPUT_READONLY, INPUT_NUMBER, INPUT_NO_SELECT_ON_FOCUS and INPUT_ENTER_RETURNS (then ui.entered is True on the frame enter got pressed), and the hint shows grey while its empty. ui.password("Password", pw, "8 letters or more") is the short way for a password box.

ui.theme has every color and size from goome_theme as an attribute (ui.theme.accent = 0xFF6FDC5F), plus dark(), light() and font.
For your own look ui.theme.skin_button = (bitmap, 8) draws buttons as a nine slice of that bitmap with 8 px borders (or give four: left, top, right, bottom). skin_panel and skin_input work the same, None goes back to normal.

🎨 Your Own Look 🎨

Pick a preset, or hand ui.theme.make one accent color and it works out the rest. For a few widgets wrap them in with ui.style(...), it takes any theme field by name and puts it back after.

ui.theme.preset("midnight")
ui.scale(1.25)

with ui.style(radius=99, accent=0xFFF59E0B):
    if ui.button("Save"):
        save()

Swapping icons for your own pngs and drawing whole new widgets with ui.custom is in the docs.
If you'd rather just read code, examples/custom.py and examples/skinned.py do both.

🪟 App Mode 🪟

goome.App is the easy way. It opens the window, runs the loop, only redraws when something happened (or while the ui is animating, or when you set app.animate = True), and closes when someone hits the x.

import goome

app = goome.App("Notes", 960, 640, flags=goome.APP_MENUBAR | goome.APP_STATUSBAR)
about = goome.Flag(False)

@app.frame
def draw(ui):
    with ui.menubar():
        with ui.menu("File") as shown:
            if shown and ui.menu_item("Quit", "Ctrl+Q"):
                app.quit()
        with ui.menu("Help") as shown:
            if shown and ui.menu_item("About"):
                about.value = True
    ui.label("hello")
    with ui.modal("About", about) as shown:
        if shown:
            ui.label("made with goome")
    ui.statusbar("ready")

@app.on_close
def closing():
    return True  # False keeps it open, like an unsaved changes check

app.run()

@app.event gets every event before the ui does (return True to eat it), @app.on_start runs once the window is up, app.redraw() asks for a frame from anywhere.
app.start() / app.step() / app.stop() let you run the loop yourself if you already have one.

Without the helper, goome.open_app("title", 960, 640) gives you a normal Goome. The window is monitor 0, so g.frame(0) and ui.frame(0) work like always and resizing sends MONITORS.
goome.open("title", mode="window", width=, height=, min_width=, min_height=, window_flags=goome.WINDOW_BORDERLESS | ...) does the same with every option.

g.title = "x", g.size = (w, h), g.pos = (x, y) move it around. g.pos raises NotSupported on Wayland
g.state = goome.STATE_MAXIMIZED / g.minimize() / g.maximize() / g.fullscreen() window state, maximize() toggles
g.drag(edges) start a native move (0) or resize (EDGE_* bits) from the click thats happening, for your own title bar
g.show() / g.hide() show or hide it
g.cursor = goome.CURSOR_HAND (or "hand") the mouse cursor
g.clipboard read it or set it, plain str
CLOSE, FOCUS, DROP events close button, focus gained (ev.id 1) or lost (0), a file dropped with the full path on ev.path
🎮 Engines And Offscreen 🎮

goome.open_offscreen(w, h, scale) never opens a window. You push your engines input in, goome draws into a buffer it owns, and you copy that onto a texture. It never blocks and never starts a thread, I made it for Unity and pygame loops.

g.push(goome.DOWN, x=, y=, button=1) / g.push(event) feed it input, any mode. push_click(x, y) and push_text("hi") are shortcuts
g.last_frame() the frame from the last end(), a Frame with .pixels (memoryview), .numpy(), .copy(), .tobytes(). Good until the next begin()
g.frame_dirty() the Rect (real px) that changed since you last asked, None if nothing did. The first one is the whole frame
g.frame_copy(buf, stride, fmt, rect) copies that part of the frame into your buffer, buf starts at the rects top left. fmt is FMT_BGRA_PREMUL, FMT_RGBA_PREMUL, FMT_BGRA or FMT_RGBA (the last two unpremultiply). No buf gives you a new bytearray
g.resize(w, h, scale) new size, sends MONITORS
g.hit(x, y) True when that spot is on the ui. Only send clicks to goome when its True and your game gets the rest
g.cursor what cursor the ui wants, copy it to your engine
g.clipboard goome keeps its own, sync it with your engines

The pixels are premultiplied ARGB, so in memory that's BGRA bytes. In pygame thats pygame.image.frombuffer(f.pixels.cast("B"), (f.w, f.h), "BGRA") blitted with BLEND_PREMULTIPLIED, or keep one surface on a bytearray and only frame_copy the frame_dirty part into it each frame like examples/pygame_embed.py does. examples/offscreen.py writes a frame to a PNG without any image library.
numpy and pygame are both optional, goome never needs them.

🖱️ Input Capture 🖱️

When you drag a slider or a window, or type in a field, goome takes the input from the game until you're done. So your camera doesnt spin around while you move a slider, even if the mouse leaves it. It does this by itself, you dont need to do anything.

if not ui.wants_mouse:
    look(dx, dy)          # your games mouse look
if not ui.wants_keyboard:
    move(keys)

ui.wants_mouse is True while the mouse is on the ui, while something is being dragged or pressed (even outside it) and while a popup is open. ui.wants_keyboard is True while a field has focus or a modal is open. ui.wants gives both as bits, goome.WANT_MOUSE | goome.WANT_KEYBOARD. Theyre up to date after ui.feed and after the frame ends.
In offscreen mode (pygame, Unity, your own engine) goome can't take anything from your game, so that's when you check them like above.

g.grab(True) / g.grab(False) does the grab by hand and g.grabbed tells you if its on. With ui.auto_grab = 0 goome never grabs and you handle it all yourself, ui.wants still works. ui.auto_grab = goome.WANT_KEYBOARD keeps just the keyboard part.
Wayland doesnt let anyone grab the pointer, so there it only takes the keyboard focus. g.can(goome.CAP_GRAB) tells you if the real pointer grab works on that desktop.

✨ Animations ✨

ui.anim(id, target, ms, ease) gives you a number that slides toward target, goome keeps the state for that id so you just call it every frame. ui.anim_color does the same for an ARGB color. While anything is still moving ui.animating is True, so your loop knows to keep drawing.

it = ui.custom("card", 0, 80)
lift = ui.anim("card lift", 1 if it.hovered else 0, 160, goome.EASE_OUT)
col = ui.anim_color("card", 0xFF2D6CDF if on else 0xFF3A3F49, 300, "spring")

The eases are EASE_LINEAR, IN, OUT, IN_OUT, SMOOTH, BACK, SPRING and BOUNCE (or their names as a str). goome.ease(kind, t) gives you the raw curve if you want to animate something yourself. examples/anim.py shows all of them next to each other.

🈳 IME And Typing 🈳

Inputs and text edits turn the IME on by themselves while they have focus, draw the text youre composing underlined at the caret, and put the finished text in. So Japanese, Chinese, Korean, dead keys and compose all just work in the ui kit.

If you read events yourself, a TEXT event is finished text and a PREEDIT event is the text being composed. ev.text has all of it (not cut at 63 bytes like ev.msg), and on a preedit ev.caret is where the caret is in it, counted in characters. An empty preedit means composing ended.
g.text_input(True, (x, y, w, h)) turns it on for your own widget and puts the candidate window by that rect. In an engine you push it in with g.push_commit("日本") and g.push_preedit("にほん", 1).

♿ Accessibility ♿

The ui kit builds a tree of everything on screen every frame, and in window mode goome hands it to the screen reader (AT-SPI on Linux, UI Automation on Windows, NSAccessibility on macOS). Its on by default in window mode and off in overlay and offscreen, ui.a11y(True) turns it on.

ui.a11y_role("button", "Knob")        # for your next ui.custom
ui.a11y_value("11")
for n in ui.a11y_tree():               # A11yNode list, parent is an index into it
    print(n.role_name, n.label, n.value, n.parent, n.checked, n.focused)
ui.a11y_action("press", node)          # same as the screen reader pressing it

In an engine you read ui.a11y_tree() and bridge it to your own a11y stuff. The actions are press, set (with a text), expand and focus, they come in as a CONTROL event so widgets react like it was a click.

😀 Emoji And RTL 😀

Text draws color emoji (COLR, CBDT and sbix fonts), skin tones and ZWJ ones, plus Arabic and Hebrew with the right letter shapes and bidi. Font.system() adds the systems emoji font by itself. For a font you loaded, give it one with font.fallback(emoji_font), it tries them in order for chars the font doesnt have (close the main font before its fallback).

goome.text_dir("rtl") sets the paragraph direction for all text, "auto" (the default) picks it from the first strong letter of each line. Inputs and text edits move the caret and select right in RTL text too. examples/text.py has a bit of everything.

📚 The API 📚

Everything from goome.h is in here, just pythony. The docs explain every part of it. Errors raise goome.GoomeError (or a subclass like goome.Again or goome.NotSupported) with the C error code on .code.

A few of the ones youll use all the time:

g = goome.open("title", backend="test")   # or open_app / open_offscreen
g.monitors()                              # areas, scale, real px
g.events(16)                              # Event objects, waits up to 16 ms
g.hotkey("alt+h", 1)                      # comes back as a HOTKEY event
img = g.capture(0, (0, 0, 200, 100))      # an Image, .pixels / .copy()
bmp = goome.Bitmap.load("logo.png")       # close() it or use with
font = goome.Font.system()                # measure(text, size) gives (w, h)

The rest (pointer, keyboard, the control fifo, Pacer, Canvas.new and the small helpers) is on the docs site. The names there are the C ones, drop the goome_ and its mostly the Python one.

🎨 Drawing 🎨

The canvas methods are the C draw functions without the goome_draw_ part:

c.rect(x, y, w, h, color)
c.rrect(x, y, w, h, 12, color)                 # one radius
c.rrect(x, y, w, h, (4, 20, 0, 33), color)     # tl tr br bl
c.rrect_grad(x, y, w, h, 12, top, bottom, sideways=False)
c.shadow(x, y, w, h, radius, blur, color)
c.circle(cx, cy, r, color); c.ring(cx, cy, r, width, color); c.arc(cx, cy, r, width, a0, a1, color)
c.poly([(80, 5), (98, 85), (40, 35)], color)
c.line(x0, y0, x1, y1, width, color); c.triangle(x0, y0, x1, y1, x2, y2, color)
c.frame(x, y, w, h, width, color)
c.rrect_line(x, y, w, h, 12, width, color)
c.erase(x, y, w, h)
c.bitmap(bmp, x, y, w, h, radius=0, tint=0xFFFFFFFF)
c.text(x, y, "built in font", color, big=True)
c.font_text(font, 20, x, y, "real font", color)
with c.clip(20, 15, 80, 50):
    ...

round_rect only takes one radius, rrect and the other rrect ones take one or a tuple of four.
c.blit(other, alpha, dx, dy) draws another canvas on top of this one, thats what Canvas.new is for.

c.pixels is a flat memoryview straight over goomes buffer (premultiplied ARGB, c.stride per row), nothing gets copied. Write into it and call c.damage(rect). Same for image.pixels and bitmap.pixels.
With numpy, numpy.frombuffer(c.pixels, numpy.uint32).reshape(c.h, c.stride) works, but numpy is never needed.

A grab stays good until you grab that monitor again. After that touching its pixels raises, call image.copy() if you want to keep them.

🧩 Examples 🧩
  • examples/hello.py - a box you can click and type into, alt+h hides it, esc or the x quits
  • examples/grab.py - python examples/grab.py [monitor] [x y w h] out.ppm saves a screen grab
  • examples/ui_demo.py - the ui kit demo with every widget, a theme editor and a stats window
  • examples/app.py - a notes app in a normal window: menus, a sidebar in a split pane and a multiline editor, plus right click menus and dialogs, and it pops toasts
  • examples/custom.py - custom widgets and the style stack: knobs and faders, a timeline and nodes you can drag, plus swatches and styled buttons
  • examples/anything.py - the same widgets 4 totally different ways (terminal, soft, game hud, dense) plus every preset and Theme.make
  • examples/offscreen.py - draws the ui with no window and saves it as a PNG, no Pillow needed
  • examples/pygame_embed.py - the ui on top of a pygame game, needs pip install pygame
  • examples/anim.py - every ease side by side, a color fade, a springy toggle and a bouncing badge
  • examples/text.py - emoji, Arabic and Hebrew in labels and inputs, with buttons to flip the text direction. python examples/text.py out.ppm [font.ttf] saves a shot instead

Theyre ports of the C examples (app.py is examples/app_ui.c, custom.py is examples/custom.c). On the test backend the ui demo comes out pixel for pixel the same as examples/ui.c, and the offscreen one matches examples/offscreen.c, same for text.py and examples/text.c.
Way more small projects live in goome-ui/examples, the Python ones are a clock, a crosshair, a color picker, a timer, a todo list and a few more.

python examples/ui_demo.py
🖥️ Where It Works 🖥️

Linux (X11 and Wayland), Windows 10 / 11 and macOS 14+, same as goome. Not every desktop can do everything, the c-goome README has the table and g.can(goome.CAP_HOTKEYS) tells you at runtime.

On Mac stay on the main thread.

📸 Screenshot 📸

the goome ui kit floating over the GNOME desktop
the ui kit at full size, just floating over my wallpaper

🧪 Testing Without A Screen 🧪

goome has a test backend that fakes a screen and plays a script of what the "user" does. Thats what all the tests here run on, no display needed:

python -m unittest        # pytest works too if you have it

You can test your own overlay app the same way, either with env vars and no code changes:

mkdir -p shots
GOOME_BACKEND=test GOOME_TEST_SHOTS=shots/ GOOME_TEST_SCRIPT="1 click 400,300; 2 key hi\n; end 10" python myapp.py

or straight from Python:

g = goome.open(backend="test", test_script="screen 800x600 1; 1 click 120,90; end 5")

The script format is in the c-goome README. The drawing tests check the exact same pixel hashes as the tests in c-goome, on every OS.

🔧 Updating goome 🔧
tools/update_native.sh ../c-goome      # or a path to any goome.h, or nothing to clone main
./build.sh test

native/VERSION keeps the commit it came from. If the layout test fails after that, a struct or constant changed and goome/_lib.py needs the same change.

🛠 Pull Requests 🛠

Want to help with python-goome? Make A pull request to dev!
Small fixes are the easiest to merge, for anything bigger open an issue first so we can talk about it. Bugs in the C side go to c-goome.

As long as it works and doesn't add a dependency its very likely to get accepted!
Read CONTRIBUTING.md before you send one.

⚖️ License ⚖️

python-goome is under the GPL-3.0.

• You can use it, change it and share it
• If you share something made with it, you have to share your source too, under the same license
• Keep the credits


In short: play fair, keep it open, and give credit where it's due.

🩷 Donate 🩷

Ko-fi (Preferred)
Patreon
Throne

🫶 Contributors 🫶
Thanks to everyone who helped out!

contributors

Metadata

Release files for goome 0.5.1

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for goome 0.5.1
File Size Uploaded Provenance Actions
goome-0.5.1.tar.gz 517.1 kB With provenance Details for goome-0.5.1.tar.gz

Built distributions (wheels)

Table of built distributions (wheels) for goome 0.5.1
File Actions
goome-0.5.1-py3-none-win_amd64.whl Python 3 none Windows x86-64 Details for goome-0.5.1-py3-none-win_amd64.whl
goome-0.5.1-py3-none-manylinux_2_34_x86_64.whl Python 3 none Linux glibc 2.34+ x86-64 Details for goome-0.5.1-py3-none-manylinux_2_34_x86_64.whl
goome-0.5.1-py3-none-macosx_11_0_x86_64.whl Python 3 none macOS 11.0+ x86-64 Details for goome-0.5.1-py3-none-macosx_11_0_x86_64.whl
goome-0.5.1-py3-none-macosx_11_0_arm64.whl Python 3 none macOS 11.0+ ARM64 Details for goome-0.5.1-py3-none-macosx_11_0_arm64.whl

Total release size: 2.1 MB

Release files / goome-0.5.1.tar.gz

Download URL goome-0.5.1.tar.gz
Size 517.1 kB
Tags Source
SHA-256 checksum
How to use checksums
bc70ccec3da1cd498e906c4dba4b3b89f4573fc5d6d42f40f72cb7758505dd03
BLAKE2b-256 checksum
How to use checksums
853d92a05bba3c04679632d0b5cd3865e762569f3637150de5b03c1e6c1c7865
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 16, 2026.

Transparency log

Release files / goome-0.5.1-py3-none-win_amd64.whl

Download URL goome-0.5.1-py3-none-win_amd64.whl
Size 399.4 kB
Tags Python 3 Windows x86-64
SHA-256 checksum
How to use checksums
609e995629a9705aa647a6af100f7d9a5954ae8ddfd9534ab61024428d1dc27b
BLAKE2b-256 checksum
How to use checksums
a0091bb971f45ee000a186cd5cde58b7e0b1c677ac38317823ac4c6a37077d9a
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 16, 2026.

Transparency log

Release files / goome-0.5.1-py3-none-manylinux_2_34_x86_64.whl

Download URL goome-0.5.1-py3-none-manylinux_2_34_x86_64.whl
Size 459.7 kB
Tags Linux glibc 2.34+ x86-64 Python 3
SHA-256 checksum
How to use checksums
fcd9c10ec137886cfc5dd8af6d6592163c143ce5ea50325867cc3874a33d0b65
BLAKE2b-256 checksum
How to use checksums
3beb287e5199a3d6b39559cb5e50aed68ff5b3024f53e5da24b7648ce40cf9e3
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 16, 2026.

Transparency log

Release files / goome-0.5.1-py3-none-macosx_11_0_x86_64.whl

Download URL goome-0.5.1-py3-none-macosx_11_0_x86_64.whl
Size 397.6 kB
Tags Python 3 macOS 11.0+ x86-64
SHA-256 checksum
How to use checksums
35f444811eccbda54feda85ccc1b8eaaae5a1553ebcb42e92c80690a4d7bc26d
BLAKE2b-256 checksum
How to use checksums
4e1ef9b78bea77178db3c6d245e2b164db900fa63735cb2dfd2bc370ce1fae85
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 16, 2026.

Transparency log

Release files / goome-0.5.1-py3-none-macosx_11_0_arm64.whl

Download URL goome-0.5.1-py3-none-macosx_11_0_arm64.whl
Size 369.4 kB
Tags Python 3 macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
756f417232d1f43d982fe82f97703d485cc9cb39e5cf10af6f50c0d73cb292e8
BLAKE2b-256 checksum
How to use checksums
148da955d989b30e603047bf0ed5a62413b0edd8ff793c75878b8f381c7498c4
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 16, 2026.

Transparency log

Security for goome 0.5.1

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

Full provenance

All 5 files in this release have been uploaded with provenance metadata.

Select from 5 files

Attestation for goome-0.5.1.tar.gz

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 16, 2026.

Transparency log

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page