What the detector sees

The sandbox runs NudeNet, an object detector that returns bounding boxes for specific body regions — not a single whole-image score. That's what lets the UI censor only the regions you've selected instead of blacking out the whole frame.

Pairing & connection codes

The sandbox app starts a detector process on your machine, then opens a tunnel so this page can reach it, and shows a short code. Entering that code (or the full URL it also shows) on the Home tab is the only way this site ever learns where your sandbox lives — nothing is registered or stored anywhere else.

Codes are single-session: closing the app, or restarting it, invalidates the old one. The address bar can also carry a code directly, as /u/<code> — useful for re-opening a tab without retyping it, not for sharing your sandbox with anyone else.

Images

Upload one image at a time. Before it's sent, the browser scales large photos down to a reasonable size for detection — this keeps the analysis fast even over a tunnel connection with limited bandwidth. Boxes come back in that scaled space and are mapped back onto the full-resolution image, so what you see (and download) is never downscaled.

Everything after detection — blur radius, style, which regions are active — is redrawn instantly in the browser with no further round trip. Use the toolbar above the preview to download or copy the finished image.

Video queue

Each mp4 becomes its own job with its own progress bar and runs independently, so queuing a second video doesn't block the first. The sandbox samples every N frames (you're asked per video), runs detection only on those, and interpolates boxes for the frames in between so the censor doesn't flicker. Frames are streamed straight into the video encoder instead of being written to disk one at a time, which is what keeps longer videos from crawling. The sandbox caps how many videos run detection at once — extras wait their turn automatically, decoding and encoding still happen in parallel.

Censor styles

Choose from a huge palette of censor effects, from blur and pixelation to outlines, glitch, rainbow overlays, dot grids, scanlines, negative inversion, and embossed fills.

• Gaussian blur — smooths the region; strength scales with box size.
• Pixelate — mosaics the region into large flat blocks.
• Frosted glass — a heavier blur plus a translucent wash, so shape reads but detail doesn't.
• Glitch — fractured color slices for an aggressive digital censor effect.
• Rainbow — bold gradient tint over the region, blended with the original image.
• Dot grid — dense dotted coverage for a stylized censor look.
• Scanlines — horizontal bands plus overlay, like old-school video distortion.
• Negative — inverts region colors for a striking, high-contrast treatment.
• Emboss — edge-driven fill with dark/light depth for a graphic, sculpted block.
• Black box / solid — opaque coverage when you want maximum privacy.

Integrate NudeNet in your own project

The sandbox's detection logic is just the open-source nudenet Python package — there's no proprietary model or API here. If you're building your own tool, you can call it directly:

# pip install nudenet opencv-python
from nudenet import NudeDetector
import cv2

detector = NudeDetector()
image = cv2.imread("photo.jpg")

results = detector.detect(image)
for r in results:
    # r == {"class": "FEMALE_BREAST_EXPOSED", "score": 0.87, "box": [x, y, w, h]}
    print(r["class"], r["score"], r["box"])

A few things worth knowing before you build on it:

• Classes. The full label set is FEMALE_GENITALIA_EXPOSED, MALE_GENITALIA_EXPOSED, ANUS_EXPOSED, FEMALE_BREAST_EXPOSED, MALE_BREAST_EXPOSED, BUTTOCKS_EXPOSED, FEET_EXPOSED, BELLY_EXPOSED, ARMPITS_EXPOSED, FACE_FEMALE, FACE_MALE. Some versions also return matching "_COVERED" classes for clothed regions — filter on score and class the same way app.py does.
• Thresholding. Drop anything under roughly 0.25 score to cut false positives; raise it if you'd rather miss borderline detections than flag clean ones.
• Batching. For many frames/images, detector.detect_batch(list_of_frames) is far faster than calling detect() in a loop.
• GPU. NudeNet runs on onnxruntime under the hood — install onnxruntime-gpu instead of the CPU package and it picks up CUDA automatically if a compatible GPU/driver is present.
• Reference implementation. app.py in this repo is a complete Flask wrapper around the same calls, including video sampling/interpolation — copy from it freely.

Privacy model

Detection and censoring both happen on your machine. This page only ever talks to the address behind your connection code — it has no separate backend of its own and keeps no copy of anything you upload.