ChitraMaya - GPU-accelerated mosaic restoration studio for video — with a real-time visual editor

seatv

Member
Jul 16, 2026
41
19
8
67
ChitraMaya
GPU-accelerated mosaic restoration studio for video — with a real-time visual editor


Hi all — first time posting about this here, so a proper introduction.

ChitraMaya is a Windows app that restores mosaic-censored video on your own NVIDIA GPU. What sets it apart from the batch-and-pray tools is that it is built as an interactive editor: you load a video, preview the restoration on your actual frames, tune it, and only commit to a full encode once it looks right. No blind overnight runs that turn out wrong.

Everything runs on the GPU end to end — NVDEC decode, TensorRT-accelerated BasicVSR++ restoration, NVENC encode — and there is no Python and nothing to configure. Download, run, done.


Why it's different

  • Test a single frame instantly. Park the playhead on any frame, hit Test Frame, and see each detected region as Mosaic → Restored side by side. Change a setting, test again — the loop is seconds, not a full encode.
  • Live segment preview. Mark a range, preview just that, decide before committing the whole file.
  • Compiles for YOUR card. No models are bundled — you download the checkpoints and compile TensorRT engines for your exact GPU, all from inside the app.
  • Built for VR / SBS. Per-eye detection for side-by-side video, so each eye is handled at full resolution.




New in v1.1

1. SBS View — a 3D compare viewer
Side-by-side VR footage looks like two distorted halves in a flat player. SBS View projects it the way a headset would — drag to look around, wheel to zoom — right on your desktop. The killer part: a draggable wipe divider with the original on one side and your restored result on the other, playing in sync. Drag it across a restored region and watch it flip between censored and clean. Pick either eye, slow it to 0.1x for close inspection, step frame by frame.



2. Add Mosaic
The reverse operation, for making shareable/SFW clips: draw up to three rectangles right on the video and pixelate them. For SBS content, draw on one eye and it mirrors to the other automatically. (The demo images in this post were made with it.)




Requirements

  • GPU: NVIDIA RTX — native builders for 50-series (Blackwell), 40-series (Ada), and 30-series (Ampere)
  • OS: Windows 10 / 11 with a current NVIDIA driver
  • That's it — CUDA, TensorRT, ffmpeg and Python are all bundled


Download & Install

⚠ IMPORTANT — the installer is THREE files. You need ALL THREE.

The .exe by itself is NOT the program — it is only the unpacker for the other two parts and cannot install anything without them. Grab all three into the same folder:

  • ChitraMaya-install.7z.001
  • ChitraMaya-install.7z.002
  • ChitraMaya-install.exe

…then run ChitraMaya-install.exe — it reassembles and extracts automatically. If the install fails right away, the fix is almost always a missing part: check that all three downloaded and are sitting together.

▶ Releases / download: github.com/seatv/ChitraMaya/releases
▶ Project & docs: github.com/seatv/ChitraMaya


Terms: By downloading or using this software you agree to use it only for purposes lawful in your jurisdiction. You are solely responsible for what you create with it and for complying with all applicable laws (privacy, consent, publicity, defamation, and intellectual property). The authors accept no responsibility and shall not be held liable for any use of the software or anything produced with it. If unsure whether a use is lawful where you are, consult a legal professional first.

Feedback, bug reports, and GPU results welcome — happy to answer questions in the thread.
 

Attachments

  • InAction-FramePreview.png
    InAction-FramePreview.png
    1.5 MB · Views: 18
  • InAction-LowRes.png
    InAction-LowRes.png
    1.4 MB · Views: 17
  • InAction-RestoreAndSave-LowRes.png
    InAction-RestoreAndSave-LowRes.png
    540.1 KB · Views: 16
  • newModelManagement.png
    newModelManagement.png
    454.7 KB · Views: 17
  • Like
Reactions: Walle12
Benchmark: ChitraMaya vs lada — same GPU, same video, same models

A few of you asked how ChitraMaya's speed compares to lada. Fair question — so I ran a head-to-head on the weakest machine I own: an RTX 3060 6 GB in a Frankenstein build (GPU-Z screenshot attached). Same source video, same detection model, same encoder settings on both sides.

The setup
  • Source: 1080p / 29.97 fps, 194,773 frames (1 h 48 m of video)
  • Detection model: lada_mosaic_detection_model_v4_accurate (both tools)
  • Restoration: lada's BasicVSR++ generic v1.2 (both tools)
  • Encoder: HEVC NVENC, preset P7, QP 18 (both tools)
  • lada run via lada-cli with the flags shown in the attached screenshot

Results (total wall clock, start to finished file)
Code:
Run                                Wall time    Avg speed   vs realtime
lada CLI (PyTorch, clip 180)       2:27:33      22.0 fps       0.73x
ChitraMaya (PyTorch, MCL 180)      2:10:54      24.8 fps       0.83x
ChitraMaya (TensorRT, MCL 90)      1:17:37      41.8 fps       1.40x

ChitraMaya with its compiled TensorRT engines finished in roughly half lada's time — 1.9× faster — on a 6 GB card. The middle row is the apples-to-apples control: same PyTorch backend, same clip length 180 as lada, and ChitraMaya is still ~13% faster purely from pipeline engineering (fully threaded NVDEC decode, batched detection, everything staying on the GPU end to end). The TensorRT row on top of that is why the app compiles engines for your specific card.

Did quality pay for it? No — and I can show it, because ChitraMaya writes a per-run report. Both ChitraMaya runs detected mosaic on the identical 121,153 frames and restored ~121,890; the TensorRT run's visible-miss count was actually slightly lower (1,379 vs 1,389 — about 1% of mosaic frames, mostly single-frame scene edges). lada doesn't emit comparable stats, so the comparison there is wall clock only.

Why it's faster: the monitor screenshots tell the story. During lada's run the GPU sits around 50% load with 2.5 GB of VRAM used — the card is half idle. ChitraMaya keeps the same card 60%+ busy with VRAM deliberately packed to ~88% (a VRAM-aware frame store sized to the card). Same silicon, more of it working at once.

Honest caveats: the headline row runs ChitraMaya at its recommended Max Clip 90 vs lada's 180 (the PyTorch@180 row is there so you can compare like-for-like); default detection confidence between the two tools may differ slightly; and this is one video on one card — your content and hardware will vary. lada's on-screen "fps" is an instantaneous reading, so I compared total wall time on both sides.

Credit where it's due: ChitraMaya uses lada's excellent models — the speedup is pipeline engineering around them, and none of this exists without that upstream work.

Screenshots attached: both consoles at completion, mid-run monitor gauges for each, and GPU-Z of the test card.


Reminder for new downloaders: the installer is THREE files (.7z.001, .7z.002, .exe) — download all three into the same folder, then run the .exe. The .exe alone is just the unpacker.

▶ ChitraMaya Releases: github.com/seatv/ChitraMaya/releases
▶ Monitoring Tool Releases: https://github.com/mountlord/nvGPUMonitor[/urlChitraMayaRunnig.png
 

Attachments

  • ChitraMayaComplete.png
    ChitraMayaComplete.png
    568.5 KB · Views: 2
  • LadaCompletion.png
    LadaCompletion.png
    57.4 KB · Views: 1
  • LadaRunning.png
    LadaRunning.png
    363.6 KB · Views: 3
ChitraMaya v1.30.00 — VR Projection, AV1 output, and two honesty fixes

New release is up. This one matters most if you work with VR content — it adds restoration support for a whole class of VR mosaics that no version before it (and, as far as I know, no other free tool's default path) could handle properly.

VR Projection — for mosaics that arrive warped

VR mosaics come in two kinds, and you can tell them apart in any flat player (PotPlayer/VLC, no VR mode):

  • Square blocks, clean grid — the studio pixelated the raw frame. ChitraMaya has always handled these well. Leave the new option Off.
  • Warped blocks — trapezoid cells, rows that bow or fan out, especially away from center. The studio pixelated in viewing space (square in the headset, warped in the file). Detection/restoration models were never trained on that pattern, so results ranged from partial to "looks restored in the stats, still mosaic on screen."

The new VR Projection dropdown (Detection panel, needs Split SBS) fixes the second kind: with Fisheye selected, each eye is warped on the GPU so the blocks become square again, everything runs in that space, and only the restored regions are warped back onto the untouched original frames. No intermediate re-encodes, background pixels never resampled.

One important honesty note: on warped-mosaic content with projection Off, the run statistics can look perfect while the output still shows mosaic — the model latches onto blocks it can't actually reconstruct. Use Test Frame and your own eyes to compare Off vs Fisheye on your title. In my field test on one such title, Off failed visibly and Fisheye restored cleanly — with identical detection stats on both runs. That's why the feature exists.

Credit where due: the approach is inspired by zelefans' vr_remove_mosaic project — reimplemented inside ChitraMaya's GPU pipeline so there are no intermediate files or quality generations.

AV1 output

The encoder can now write AV1 alongside HEVC and H.264 — better compression at the same quality, ideal for archiving big VR files. Needs an RTX 40-series or newer to encode (the app checks your card up front and says so plainly). Your QP setting stays on the familiar HEVC scale; the app maps it to AV1's quantizer internally and logs the mapping.

Image Size — runtime detection resolution

Detection input size (640–960) is now a dial in the UI. Why you care: on 4K+ VR/SBS frames the old fixed 640 downscales too far and can miss small/faint mosaics. In my A/B/C test on 8K SBS content, 640 missed frames; 800 caught everything (960 too, but slower for no extra catches). Recommendation: 800 for 4K+ VR/SBS, 640 for flat. If you use TensorRT detection, recompile the detection engine at 800 in Manage Models to keep full speed.

Fixes worth knowing about

  • Silently skipped frames in dense scenes — fixed. Detection post-processing had an internal time limit; when a busy high-res scene exceeded it, the rest of the batch quietly got no detections (mosaic passed through unrestored, just a console warning). The limit is now far higher. A long 8K run that used to print ~200 of those warnings now prints zero.
  • AV1 remux — fixed, plus if a final remux ever fails, you now get a loud REMUX FAILED banner (and your encode is kept on disk, recoverable) instead of a misleading "Done".
  • Stale settings — fixed. Some dials (notably detection Score) could silently keep their old value on an already-warm pipeline until app restart. All run-affecting settings now take effect between runs.

Also: the top bar now shows the full path of the loaded file, and the Blend Mask option formerly labeled "FaceFusion" is now called "Face Swap" (same behavior).

Get it

▶ Releases: github.com/seatv/ChitraMaya/releases
▶ Test Video Clip for VR Projection: get it at storage.to/Pjg2ciqCl

Reminder: the installer is THREE files (.7z.001, .7z.002, .exe) — download all three into the same folder, then run the .exe. The .exe alone is just the unpacker.


No models ship with the app — download checkpoints (lada + zelefans repos are pre-loaded in Manage Models) and compile TensorRT engines for your own card, all in-app. Feedback and issue reports welcome on GitHub — please, no explicit content in issue attachments.
 
  • Love
Reactions: r00g
ChitraMaya v1.40
Batch a whole folder. Sharper close-ups. No more shimmer. No more terminal.

batchsetup-png.3836552

ChitraMaya is a Windows app that restores mosaic-censored video on your own NVIDIA GPU — built as an interactive editor: preview the restoration on your actual frames, tune it, then commit. Everything runs on the GPU end to end (NVDEC → TensorRT → NVENC), no Python, nothing to configure. v1.40 is the biggest update yet.


★ New in v1.40 ★

1. Process Folder — real batch mode
Point it at a folder and walk away. Every video is processed with your current settings; models load once and stay warm. The queue shows per-file status and elapsed time, already-done files are skipped on re-run (that's your resume button), outputs are never overwritten, and one bad file — even a GPU hang, a watchdog catches it — can't kill the batch.

batchinprogess-png.3836551

2. RTX Super-Res second stage — sharper close-ups (recommended)
The restorer works on a fixed-size crop; big on-screen regions used to get stretched at paste-back and go soft — worst exactly on close-ups and VR. Now the restored region is upscaled 2×/4× by NVIDIA RTX Super-Res before paste-back, so the final resize shrinks instead of stretches. Costs ~4% run time. Small regions automatically keep the untouched path.

3. Temporal Stability — kills the shimmer (recommended)
Restoration models flicker frame to frame — fizzle and wiggle in fine detail. The new dial smooths restored regions across a 7-frame window, but only where the content agrees, so real motion passes through untouched. Weights are bundled (Apache-2.0) — nothing to download, flip it on and it works. Especially valuable on 8 GB cards.

4. A proper windowed app
No terminal window anymore. Console output lives in an in-app Console panel and in ChitraMaya-console.log next to the exe. Terminal users get ChitraMaya-cli.exe — same app, live output, for headless runs and engine compiles.

5. Test Frame history
The tuning loop got a memory: the enlarged preview keeps your last 5 attempts on a frame. Change a setting, re-test, then flip between attempts with arrows or numbered slots — same frame, same region, one click apart. Hover a number to see which settings produced it.

6. AV1 finally seeks properly
If your AV1 outputs from earlier versions froze or broke up when you tried to fast-forward: found it, fixed it. The hardware encoder writes the stream's sequence header only once at the very start, so no later keyframe was a true seek point. ChitraMaya now repairs the stream automatically before packaging -- validated on a 2.5-hour 4K file, scrubs cleanly in every player we tried. Full encoder preset ladder (P1-P7) is now selectable too.

Plus: the final scene of every video now gets the full quality treatment (an end-of-file path used to skip the second stage), stall/eGPU-link warnings for long runs, wider batch windows for long filenames, and documented censoring workflows (max-recall settings + a two-pass leak check) for the SFW Add Mosaic side.


The 8 GB rule (worth pinning)

On an 8 GB card: Max Clip Length 60, encoder preset P5. Bigger MCL loads an engine set that ~doubles resident VRAM — the run starts fine, then dies mid-encode once the driver starts paging (eGPU users are hit hardest). MCL 60 + P5 runs the entire new quality stack within budget. 12 GB+ cards: run MCL 90+, it's worth it.

Recommended preset for v1.40: Secondary = RTX Super-Res, Temporal Stability = 2, MCL per your card.


Requirements & download

  • Windows 10/11, NVIDIA RTX card (50/40/30-series have native TensorRT builders; others compile via PTX fallback), current driver.
  • AV1 output needs RTX 40-series+. RTX Super-Res needs an RTX card + recent driver.
  • No Python, no CUDA install — everything is bundled.

Download from the Releases page: https://github.com/seatv/ChitraMaya/releases

The installer is THREE files — you need ALL THREE in the same folder: ChitraMaya-install.7z.001, ChitraMaya-install.7z.002, ChitraMaya-install.exe. The .exe alone is only the unpacker. Run the .exe after all three finish downloading.

Upgrading from v1.30: no breaking changes — your engines, models, and configs carry over. The new features default to Off.


;"} ;"} ;"}
 

Attachments

  • BatchInProgess.png
    BatchInProgess.png
    105.8 KB · Views: 96
  • BatchSetup.png
    BatchSetup.png
    157.1 KB · Views: 191
ChitraMaya v1.41.00 — Intel Arc (XPU) Edition — EXPERIMENTAL

NVIDIA users: there is nothing for you in this release — do not update. Your current NVIDIA release remains current. Everything below is about the new Intel Arc edition only; the next NVIDIA feature release will be clearly announced as such.

_______________________________________________________________________________________________________________________

ChitraMaya now runs on Intel Arc GPUs. The full product path — detection, BasicVSR++ restoration, temporal stabilization, and hardware encode — runs on the Arc, with Quick Sync doing the video decode AND encode in fixed-function silicon.

⚠ READ THIS FIRST — tested on ONE machine, ONE card.
The Arc edition has been field-tested on exactly one system: an Arc A580 8GB (Alchemist) on Windows 11, without Resizable BAR. A750/A770, the B-series (Battlemage), and Intel iGPUs are completely untested — they may work, they may not. This is a public test release: use with caution, expect rough edges, and please report what you find. Every bug report at this stage is genuinely valuable.

Installing — ONE file, no installer

Unlike the NVIDIA edition's three-part installer, the Arc edition is a single archive: ChitraMaya-xpu-install.7z. Download it, extract it anywhere (Windows 11 Explorer opens .7z natively; otherwise 7-Zip or WinRAR), run ChitraMaya.cmd. Done.

What works (validated on the test machine)

  • The complete interactive editor: Test Frame previews, segment restore, Process Folder batching, Add Mosaic, SBS View
  • Quick Sync hardware decode — the app probes each file and picks QSV → D3D11VA → CPU automatically, and tells you which it chose
  • Quick Sync hardware encode — AV1, HEVC, and H.264
  • No engine compiling at all — TensorRT doesn't exist on Arc; models run directly in PyTorch. Download models in Manage Models and just run
  • Temporal Stability (the anti-shimmer stage) — weights bundled, works out of the box
  • Crash hardening — a failed run still gives you a playable partial output plus a diagnostic .misses.json with the console tail embedded
  • Long-run protections: stall watchdog, VRAM telemetry, and the app holds your system awake during runs (no more overnight jobs killed by the sleep timer)

What to expect — honest numbers

  • It is slow. On the same 4K test file: RTX 3060 = 58 seconds, Arc A580 = 18 minutes — about 20× slower. This is the current state of PyTorch's Intel GPU support (a software-maturity gap, not your card or your settings). We tested the obvious optimizations — channels-last, bf16, torch.compile — and none of them help this model on today's stack. The gap should narrow as Intel's software matures.
  • NVIDIA-only features (RTX Super-Res, the PCIe monitor) are unavailable on Arc by design, with clear messages.
  • 8 GB Arc cards handle 4K flat video comfortably. 5K / VR / SBS content is NOT recommended on 8 GB. If you have a 16 GB Arc, your field reports on big content are exactly what we're hoping for.

Requirements

  • Windows 10/11, 64-bit
  • A current Intel graphics driver — that's it; ffmpeg and all runtimes are bundled
  • Resizable BAR recommended (BIOS: CSM off, Above 4G Decoding on, ReBAR on) — though note the test machine ran WITHOUT it, so ReBAR configs are themselves untested

Reporting problems

Attach two files to any issue: ChitraMaya-console.log (next to the exe) and the *.misses.json written beside your output — together they carry the settings, stats, and final console lines. State your GPU model, driver version, and ReBAR state (GPU-Z shows it). And as always: no explicit content in issues, per the issue template.

Download: github.com/seatv/ChitraMaya/releases

_______________________________________________________________________________________________________________________

One more time for the folks skimming: NVIDIA users, skip this release — it changes nothing for you. Arc owners: welcome aboard, and bring bug reports.
 
If you are using the Intel ARC build, please enable Resizable BAR in your BIOS - it is worth 7-9x. Same machine, same BIOS, same card, only the ReBAR toggle changed - see the timings below
metricno ReBARReBAR ratio
Clips27.7s avg2.9s avg~9.5×
Restoration897.2s101.4s~8.9×
Detection199.3s33.7s~5.9×
Total Time19:122:37~7.4×
BIOS checklist: CSM off -> Above 4G Decoding on -> Resizable BAR on (Above 4G alone does nothing - it is only the prerequisite). Verify with GPU-Z's "Resizable BAR" field. With ReBAR enabled, the A580 runs about 3x behind a comparable NVIDIA card - the ~20x in the original release notes was measured without ReBAR.
 
ChitraMaya v1.50.00 — Measured-Quality Release
This is a big one — hence the version jump. Full-clip temporal restoration, a measurement harness so you can check our claims yourself, an 8 GB preflight that warns you before a run instead of failing after, and a long tail of field-reported fixes. All editions (NVIDIA, AMD ROCm, Intel Arc) benefit from this release.
_______________________________________________________________________________________________________________________
Installing
⚠ NVIDIA edition: if the release lists THREE files, you need ALL THREE.
The .exe by itself is not the program — it is the unpacker for the other two parts. Download all the ChitraMaya-install.* files into the same folder, then run ChitraMaya-install.exe. If the release page shows only a single ChitraMaya-install.exe, that one file IS the whole installer — double-click it and pick a folder.
The AMD (ROCm) and Intel Arc (XPU) editions are each one *-install.exe: double-click, pick a folder, done.

Headline: full-clip temporal restoration
BasicVSR++ propagates information between frames — a detail visible in frame 40 helps reconstruct frame 140. Until now, the PyTorch restoration path silently split every scene into 32-frame chunks, resetting that propagation at each seam. As of v1.50.00 the model sees the whole clip in one pass, exactly as its authors intended.
  • UI: with Use Tensor off, the Max Clip Length dial is now unlocked up to 600 frames — the dial IS the temporal window on the PyTorch path. Longer = smoother, more consistent restoration, at the cost of memory.
  • Safety valve: if a long window doesn't fit your RAM/VRAM, set "restoreChunkFrames": 32 in ChitraMaya-config.json (or --restore-chunk-frames 32 headless) to restore the old chunked behavior. 0 (the default) means no cap.
  • AMD and Intel editions (Releases to follow at a later time): these run PyTorch restoration always, so this is the single biggest quality change those editions have ever received. Expect visibly steadier restored regions — and higher memory use on long scenes; the safety valve above is your dial.
  • NVIDIA TensorRT path: unchanged — compiled engine sets still govern the clip window there (see the VRAM section below).
Credit where due: the correct no-cap behavior was confirmed by studying lada's pipeline, which has had it right all along. Standing on shoulders, as always — see the README acknowledgements.

Measured: how we now compare — and the tool so you can check
We built a paired-evaluation harness and ran a five-way controlled comparison — original vs. mosaic vs. restorations from lada and from ChitraMaya, on identical inputs with matched settings.
  • Core restoration is at parity. With enhancements off and settings matched, ChitraMaya's restored regions are statistically indistinguishable from lada's — as expected, since both build on the same model lineage and we credit that lineage openly.
  • The enhancement stack is real, and it measures. With RTX Super-Res + Temporal Stability enabled, the full ChitraMaya stack produced the lowest frame-to-frame flicker of every arm we measured — better than either tool's core output — while holding fidelity.
  • The harness ships in this release: tools/ab_eval.py (run from a source checkout). It aligns clips automatically, masks metrics to the restored regions, and reports fidelity, texture, motion, and flicker per arm, plus side-by-side renders and a contact sheet.
  • New detection option to support it: "detection": { "dump_rois": true } (or --det-dump-rois) writes every detection rectangle per frame into the run's .misses.json.

Smarter about 8 GB cards: warned before, not failed after
TensorRT restoration engines reserve GPU memory for the clip size they were compiled at — not the Max Clip value you dial. Selecting MCL 60 while only a 180-frame engine set is on disk still pays the 180-frame memory bill, and on an 8 GB card that ends in a mid-run encoder failure ("NVENC error 8") that looks like anything but what it is.
  • Preflight CAUTION at engine selection. If the engine set about to load is too large for your card, the console now says so before processing starts — naming the set, the reason, and the fix.
  • Encoder headroom check. After models load, if free VRAM is below what the encoder realistically needs, you get a warning up front instead of a cryptic failure at first flush.
  • Guidance: compile engine sets at each Max Clip you actually use (e.g. 30/60/90/120 — Manage Models, one compile each). The loader always picks the smallest compiled set that covers your dial. On an 8 GB card, sets of 90 and below are comfortable; 120 is marginal; 180 needs a 16 GB card.
  • The frame-store banner now correctly says RAM when frames are held in system memory rather than VRAM.

Fixed: the big-file finalize (50 GB+ outputs)
The end-of-run remux had a flat 15-minute timeout — fatal for a 50 GB output on a slow disk, since the fast-start option rewrites the entire file a second time. A finalize that was still working got killed, turning a finished encode into a failed run. The timeout now scales with output size (a 50 GB file gets over an hour), and if it does trigger, the message points at the recovery script, which rebuilds the playable file from the preserved raw stream with no re-encode.

Fixed: PyNvVideoCodec 2.2 compatibility (NVIDIA)
NVIDIA's PyNvVideoCodec 2.2 changed the encoder's return format, which broke encoding for anyone who upgraded the package. ChitraMaya now handles both the 2.1 and 2.2 formats transparently. requirements.txt was refreshed to match the tested stack, including the nvidia-vfx runtime that RTX Super-Res needs.

Fixed: your player no longer guesses colors
Restored outputs used to ship without color-space tags, even when the source carried them, so players guessed — the mystery "it pops more" effect that started our whole measurement campaign. The output now carries the source's color tags (bt709, range, etc.) in the codec's own metadata, surviving stream-copy remuxes.

Quality-of-life
  • Two instances, two ports, two logs. Launching a second copy now announces its port clearly (Instance 2: port 5100 busy; running on port 5101) and writes its own console log.
  • Model-file errors in plain language. Missing checkpoint → "download it via Manage Models"; truncated download → diagnosed by size; wrong file type selected → targeted hint.
  • Empty model dropdowns now tell you what to do instead of silently showing nothing.
  • PCIe watchdog: all-clear messages. Prints an explicit "RECOVERED" note when a transient down-train heals itself. A down-train without recovery remains the serious signal.
  • Self-check now prints each GPU's VRAM and reports versions for every bundled component.
  • End-of-run stats are honest about the tail — time restoring the final clip after the input ends is now billed to restore time.
  • Packaging (all editions): every edition's build script now accepts -FfmpegDir to pin exactly which ffmpeg gets bundled.

Acknowledgements

The full-clip temporal window behavior was confirmed against ladaapp's lada. ChitraMaya exists because of ladaapp and HypoX64 before him, who published their work openly.

ChitraMaya's BasicVSR++ TensorRT sub-engine implementation is ported from Kruk2's Jasna, as the source file headers have always noted — both projects are AGPL-3.0.

Upgrade notes
  • No breaking changes. Compiled engines, downloaded models, and saved configs carry forward as-is.
  • PyTorch-path outputs will differ from previous versions — on purpose. Set "restoreChunkFrames": 32 if you need bit-comparable behavior with old runs.
  • 8 GB NVIDIA cards: open Manage Models once and compile restore engine sets at the Max Clip values you actually use (30/60/90 recommended).
  • Source-checkout users (NVIDIA): pip install -r requirements.txt after pulling.
_______________________________________________________________________________________________________________________
Download: github.com/seatv/ChitraMaya/releases
 
What is the difference between lada model and rfdetr model?
Good question. They're two different detection model families from two different authors, doing the same job — finding mosaic regions. The lada models (by ladaapp) are YOLO-based detectors; ChitraMaya uses those (plus zelefans' VR-trained YOLO models). The rfdetr models (by Kruk2, for Jasna) are built on RF-DETR, a newer transformer-based detection architecture. Architecture matters less than training data — each author trained on their own dataset, so results differ by content and by the score threshold you use. ChitraMaya doesn't currently run RF-DETR models; if there's real interest in supporting them, that's worth hearing about.
 
  • Like
Reactions: mei2
Good question. They're two different detection model families from two different authors, doing the same job — finding mosaic regions. The lada models (by ladaapp) are YOLO-based detectors; ChitraMaya uses those (plus zelefans' VR-trained YOLO models). The rfdetr models (by Kruk2, for Jasna) are built on RF-DETR, a newer transformer-based detection architecture. Architecture matters less than training data — each author trained on their own dataset, so results differ by content and by the score threshold you use. ChitraMaya doesn't currently run RF-DETR models; if there's real interest in supporting them, that's worth hearing about.

Thanks. I haven't used ChitraMaya nor Ladaapp. I have been "buying" from sehuatang decensored movies done by lada and jasna. I assume the jasna one had used rf-detr. In my experience the ones in rfdetr are more to my liking. Later I heard that the older movies are more suitable for jasna, while the new movies are better fit for lada. My collection is almost entirely old movies from pre-2019, so that may explain my subjective experience.

This is why I was interested to learn about the difference between yolo vs rfdetr, and the science behind them.
 
On ChitraMaya, there is a mode in which you can visualize what is being detected. It will color the detected area with a shade of your choice. With lada models and zelefan's VR models misses in detection are really low. Reconstruction is where the challenges are. For the most part, I use synthetic mosaics to measure detection, as it is easier to determine what was missed. Not a fan of having to visually scan for misses on adult videos, it can get tiresome very fast.
I do recall ladaapp commenting on a github issue discussion thread that there are some ROIs where the BasicVSR++ model just refuses to reconstruct - I am paraphrasing.
 
  • Like
Reactions: mei2
Thanks. I haven't used ChitraMaya nor Ladaapp. I have been "buying" from sehuatang decensored movies done by lada and jasna. I assume the jasna one had used rf-detr. In my experience the ones in rfdetr are more to my liking. Later I heard that the older movies are more suitable for jasna, while the new movies are better fit for lada. My collection is almost entirely old movies from pre-2019, so that may explain my subjective experience.

This is why I was interested to learn about the difference between yolo vs rfdetr, and the science behind them.
sehuatang used their own tweaked version of lada and jasna iirc like lada 0.11.1 instead of the latest official 0.11.0
lada has slower pace of development or even decision to discontinued at some points I think.
As for old movies and general, I read on other forums that people prefer yolo v2, older model, to v4. Some also uses zelefan models with lada before jasna and chitra out with new models like rfdetr.
jasna and chitra have more frequent updates and optimization for quality + speed + vram usage
 
  • Like
Reactions: mei2
Reading the notes for this, you wanted the log. Do you want it here? or where on Github?
Ideally on github, that way I can track and close (it is fine if you post it here too). Thank you for testing, and bearing with the challenges. I am still waiting for my card to arrive, so still flying blind.
 
sehuatang used their own tweaked version of lada and jasna iirc like lada 0.11.1 instead of the latest official 0.11.0
lada has slower pace of development or even decision to discontinued at some points I think.
As for old movies and general, I read on other forums that people prefer yolo v2, older model, to v4. Some also uses zelefan models with lada before jasna and chitra out with new models like rfdetr.
jasna and chitra have more frequent updates and optimization for quality + speed + vram usage
Thank you for your comments. I started writing ChitraMaya with AI assistance when lada disappeared from github one morning. This is the second iteration. I think Jasna and ChitraMaya (gRestorer, its predecessor) started around the same time. Kruk2 implemented TRT first, I borrowed his compilation scheme and added TRT support to ChitraMaya. I am testing the port of Jasna's latest TRT implementation (Kruk2 mentioned that I was using an older version on another thread), once the testing and benchmarks are done, I will release a patch update that is only few MBs.
 
sehuatang used their own tweaked version of lada and jasna iirc like lada 0.11.1 instead of the latest official 0.11.0
I have not looked at sehuatang site - did they modify code or are they using their own models? Either way, if they "selling" stuff, I suppose they have negotiated some sort of licensing.