mrkeyoor.comAsk

CAPCOM-TD-OSS/REDoxtested 17 Oct 2026commit 1761540

REDox review

Evaluate REDox for editable documents and shared format converters.

  • Safety failed
  • Install 17 s
4/4tests passed
  • Build 12 s
  • 8 packages
Dev Toolsevaluationupdated 14 Nov 2026
+11stars / 7d

REDox, styled RE:Dox, is CAPCOM's .NET structured-data library. Its shared token document model supports reading, editing, conversion and serialization. Compatibility packages adapt options from System.Text.Json, Newtonsoft.Json and DataContractJsonSerializer.

Verdict

Evaluate REDox for editable documents and shared format converters. Keep native System.Text.Json when contract customization or required-constructor validation is essential: issue #6 reports both diverging with CAPCOM.REDox 1.0.3 and its 1.0.3-preview adapter. Our four passing Go checks belong to external/toml-test; the later Compose-based attempt stopped at its safety step.

REDox infographic: Reading, editing and conversion of structured data, plus our test result and who it suits
Tested 17 October 2026: 4 of 4 source tests passed. Before that: source install 17 s, build 12 s.

We ran it

Lab card: what happened when we ran REDox
Lab card from our sandbox run
Screenshot of REDox (github.com/CAPCOM-TD-OSS/REDox)
github.com/CAPCOM-TD-OSS/REDox
Install✓ · 17s8 packages
Build✓ · 12s
Tests✓ · 3s4 passed · 0 failed of 4 (go test)
Repo4773 files~192,853 lines of source · 179.8 MB · 1 CI workflows · tests dir

Answers from our run

Does REDox build from source?

Dependencies installed in 17 seconds (8 packages), and the build succeeded in 12 seconds. We cloned commit 1761540 into a clean Debian container with 3 CPUs and no project-specific setup.

Do REDox's tests pass?

Yes. The project's own test command finished in 3 seconds and reported 4 passed, 0 failed (go test).

Who should not use REDox?

Applications requiring the System.Text.Json contract customization and required-constructor behavior that issue #6 reports diverging through the 1.0.3-preview adapter.

What are the alternatives to REDox?

System.Text.Json, Newtonsoft.Json, DataContractJsonSerializer. Evaluate REDox for editable documents and shared format converters.

Setup4/5Our source checkout installed in 17 s and built in 12 s with 8 dependencies, but we did not run a README task.Editor’s note: The successful harness selected external/toml-test; installation and execution of the documented .NET solution were not reproduced.
Docs4/5The README has an install command and a usage section (“3. 30-second example”); we did not run its quickstart ourselves.Editor’s note: English instructions and security guidance are supplied, but their execution and coverage do not support a calibrated numerical rating.
Community4/5Last push on 2026-10-19, 1,766 stars and maintainers answered or closed 5 of the 8 most-discussed issues we sampled.Editor’s note: Issue reports and maintainer responses document activity without establishing support capacity or confirmed production adoption.
Maturity3/5Latest release v1.0.3 on 2026-10-16, repository created 2026-09-30 and its test suite passed in our sandbox (4 of 4 passed).Editor’s note: The evidence includes preview-adapter divergences but no independent main-solution or production-workload assessment.

How we score

Discussed on

  1. hnCapcom RE:Dox, open source serialization/deserialization for game engines35 points

Who it’s for

.NET developers who need editable structured documents or converters shared across formats.
Teams comparing compatibility-adapter behavior with the serializer their application already uses.

Who it’s NOT for

Applications requiring the System.Text.Json contract customization and required-constructor behavior that issue #6 reports diverging through the 1.0.3-preview adapter.
Services accepting unauthenticated DOX uploads: the README restricts DOX input to trusted sources.
Teams requiring stable behavior from packages the README labels preview.

Setup reality

Our October 17, 2026 sandbox at commit 1761540 selected external/toml-test. Installation succeeded in 17 seconds with 8 dependencies recorded, building took 12 seconds, and go test completed in 3 seconds with 4 passed and 0 failed of 4.

The configured sandbox had 3 CPUs, 8 GB RAM and image golang:1.24-bookworm. The README documents a different setup: .NET 10 or later, CAPCOM.REDox NuGet packages, and external data submodules for the solution build.

The November 13 hands-on runner stopped at its Compose-file requirement because none of its four accepted filenames existed. Teardown succeeded.

CAPCOM-TD-OSS/REDox deserves consideration when an application needs editable structured documents or converters shared across formats. For a serializer migration, issue #6 supplies the more immediate decision: its reported 1.0.3-preview adapter serialized an excluded property and accepted a missing required constructor argument. Keep native System.Text.Json when those behaviors control your data boundary. Our October sandbox passed four Go checks in external/toml-test, and the November hands-on runner stopped at its Compose-file requirement.

REDox connects formats through an editable token model

RE:Dox parses structured data into a shared token representation for reading, editing, conversion and serialization. The README identifies it as a .NET engine developed within CAPCOM's REX Technology. Its NuGet packages use the CAPCOM.REDox prefix, while C# namespaces use REDox. Those identifiers distinguish this library from other software and organizations named Redox. REDox README and package overview

The editable document model is a concrete reason to investigate it. The README's player example changes a name, adds a property, removes a level and edits inventory entries through a parsed document. Another documented use is sharing a DataConverter<T> implementation through the common DataReader and DataWriter abstractions. These capabilities answer a document-processing problem that a comparison of serializer throughput alone would leave out.

The README lists core, CBOR, MessagePack, Dynamic, DataContractJson and INI packages as public. TOML, XML, HTML, CSV and the System.Text.Json and Newtonsoft.Json compatibility packages are preview. Select the package that supplies the needed behavior rather than treating the repository as one uniform compatibility promise. For document conversion, the README describes formats sharing a common token representation, including JSON-to-CBOR and CBOR-to-MessagePack paths.

What people use REDox for

Issue reporters used REDox for date-compatibility investigation, custom-converter benchmarking and dictionary-allocation work. These are identifiable contributor activities with inputs and reported outcomes. They give a prospective user more useful evaluation cases than an adoption claim would: each points to a behavior that can be compared with an existing serializer or with a proposed implementation change.

Who used it What they did Reported outcome
Issue #1 reporter Compared Microsoft JSON timestamp conversion with expected local DateTime behavior Reported an incorrect local time; all 225 Utf8Helper tests passed with the proposed fix. Date-offset report
Issue #7 reporter Serialized 1,000 rows using Guid and TimeSpan converters through the System.Text.Json adapter Reported 9.50 times the managed allocations of native System.Text.Json. Converter benchmark
Issue #8 contributor Compared untyped dictionary deserialization before and after pre-sizing capacity Reported about 40.9% fewer managed allocations and a 15.4% lower measured mean for 1,000 properties on the proposed branch. Capacity proposal

Issue #1 makes the date problem tangible. For /Date(1705285810000+0900)/ on a machine using UTC+01:00 for that date, the reporter expected 2024-01-15 03:30:10 and obtained 2024-01-15 11:30:10. Both values had DateTimeKind.Local. Checking the kind alone would therefore miss the difference. The maintainer reported changing conversion to treat milliseconds as UTC instants before converting to machine-local time. Issue #1 date conversion

What happened when we ran it

Our November 13, 2026 hands-on attempt stopped at the safety step because no Compose file existed. The runner required compose.yaml, compose.yml, docker-compose.yaml or docker-compose.yml, and its explicit failure names all four. The teardown record says it succeeded. The failure concerns a deployment requirement imposed on this library checkout.

The summary record says the repository deployed through its own Docker Compose with every port bound to 127.0.0.1. That conflicts with the explicit missing-file failure. We give the failed step precedence and describe the attempt as stopped. Keeping both records visible matters because repeating the summary alone would turn a failed prerequisite into a successful deployment claim.

Our earlier run used commit 1761540 on October 17, 2026 and selected the Go project in external/toml-test. We measured installation at 17 seconds, building at 12 seconds and tests at 3 seconds. The results below retain that selected-project scope so the four passing checks are attached to the code the harness actually ran.

Recorded October step Outcome Scope
Install Succeeded in 17 seconds, 8 dependencies recorded Selected Go subproject
Build Succeeded in 12 seconds Selected Go subproject
Tests Succeeded in 3 seconds, 4 passed and 0 failed of 4 Recorded go test checks

The sandbox configuration recorded 3 CPUs, 8 GB RAM and image label golang:1.24-bookworm. The checkout contained 4,773 files, approximately 192,853 source lines and 179.8 MB. The scan found one CI workflow, a tests directory and no Dockerfile. These observations describe the checkout and configured sandbox. The README separately identifies toml-test as external TOML conformance data used by the .NET project's tests and benchmarks.

Where people get stuck: released fixes and open adapter reports

Maintainers reported v1.0.1 fixes for culture-dependent conversions, XML/CSV/TOML parser failures and numeric-to-string compatibility. Issue #6 describes a later setup using CAPCOM.REDox 1.0.3 and CAPCOM.REDox.Serialization.SystemTextJson 1.0.3-preview. Keeping those versions beside the symptoms separates historical corrections from the open contract report. Culture fix, parser report, scalar-conversion fix

Attributed symptom Recorded response or status Useful acceptance case
Issue #3: dot-decimal TOML parsing depended on ambient culture, including pt-BR Numeric and timestamp conversions made culture-independent; maintainer reported v1.0.1 release Parse the same literal under a comma-decimal culture.
Issue #4: XML parsing could hang and allocate continuously; XML, header-based CSV and TOML could produce cyclic token trees Maintainer reported XML/CSV/TOML fixes released in v1.0.1 Include malformed documents and traversal after parsing.
Issue #5: numeric JSON values were accepted for string properties AllowRelaxedScalarConversion added and disabled in System.Text.Json-compatible settings; maintainer reported v1.0.1 release Require rejection of a numeric value for a string field.
Issue #2: date provider and parsing styles were ignored Maintainer reported a configuration fix in commit bf910e307c1637a0296b36c30b265a2bdfb19a2d Compare formatted output and DateTime.Kind with the framework serializer.
Issue #6: contract customization and required-constructor settings were ignored Open report for the 1.0.3-preview adapter Compare property exclusion and missing-argument rejection with native STJ.

Issue #4 reports consequences beyond a parse exception: DValue.Parent and GetPath() could hang while allocating, while ToJsonString() could throw InvalidOperationException for exceeding maximum depth 64 or terminate the process through stack overflow. The reporter described more than 1 GB allocated in about 0.2 seconds for the XML parse cases and about 0.5 seconds for a traversal case. Those are the reporter's observations. Parser failure details

Issue #2 shows why matching the ambient culture can conceal a compatibility defect. With a Japanese requested provider and invariant ambient culture, the framework produced Japanese date text containing 2024年1月2日, while REDox produced text containing Tuesday, 02 January 2024. The reporter explained that an existing test could pass accidentally when both cultures were Japanese. Deliberately separating those inputs makes the requested behavior explicit. Date-provider reproduction

Custom converters change the allocation comparison

Issue #7 reports 1,283.26 KB allocated per operation through REDox's System.Text.Json adapter versus 135.14 KB through native System.Text.Json. The workload serialized 1,000 rows with ordinary Guid and TimeSpan converters to UTF-8 bytes on both sides. Its reproduction specifies .NET 10, BenchmarkDotNet 0.15.8, CAPCOM.REDox 1.0.3 and the 1.0.3-preview adapter. Custom-converter allocation report

Issue #8 examines a different path: untyped dictionary deserialization. The contributor proposed initializing dictionary capacity from the token map's known entry count. For 1,000 properties, reported allocations fell from 170.05 KB to 100.52 KB and mean time from 52.790 μs to 44.659 μs. For 10 properties, allocations fell from 1.59 KB to 1.05 KB. The contributor also reported full-solution validation with 43,774 passed, 12 skipped and zero failures. Those counts belong to the contributor's validation. Dictionary-capacity proposal

These results concern different implementation paths. Existing STJ converters exercise the compatibility adapter; pre-sizing a dictionary changes untyped object materialization. A useful comparison starts with the path a consuming application will call, its target types and its serializer options. The README's core benchmark datasets answer another question again, so their headline ratios should stay attached to those datasets rather than decide an adapter migration.

Security boundaries: trusted DOX and document ownership

The README says to accept DOX data only from trusted sources and advises against deserializing it from unauthenticated network clients or user uploads. Its recommended alternative for untrusted input is a text format such as JSON. That restriction gives an immediate architectural decision: a public upload boundary needs an input format consistent with the documented guidance. README security guidance

The README distinguishes read-only DElement references from mutable DValue, DObject, DMap and DArray instances. Mutable instances require external synchronization or a separate instance per thread because their internal state can change during operations that appear read-only. For a document-processing worker, ownership and cloning therefore belong in the design alongside the choice of serializer and format. The documentation provides a specific rule to follow rather than a general thread-safety label.

Issue #6 provides a separate contract example. Native System.Text.Json omitted a synthetic Secret property after contract customization, while the REDox adapter serialized it. Native STJ also threw JsonException for the missing constructor argument, while REDox accepted it. These reported outcomes make property exclusion and required-input rejection concrete acceptance cases for applications using those settings. Contract and validation reproduction

English setup instructions specify .NET 10 or later

The English README requires .NET 10 or later and documents installing the core package with dotnet add package CAPCOM.REDox. Preview packages use --prerelease. Its source-build instructions clone with submodules, build REDox.slnx in Release configuration and run the solution's tests. These are documented commands, distinct from the Go commands selected by our harness. Requirements and build instructions

Issue #4's parser report and part of its maintainer discussion are Japanese, while the README supplies English examples and security instructions. That makes the README the direct English entry point for setup and package selection. For the historical parser cases, the issue itself supplies the detailed inputs and failure descriptions. Read the package status together with those reports so a released format fix and a preview compatibility package retain their separate meanings.

REDox vs System.Text.Json, DataContractJsonSerializer and Newtonsoft.Json

Native System.Text.Json preserved the contract exclusion and missing-constructor-argument rejection in issue #6's reproduction. REDox's editable document model and shared converter abstractions supply a different reason to consider it. The comparison below ties each alternative to the behavior recorded in the supplied issues, giving a migration decision a concrete reference implementation rather than a general ranking.

Alternative Evidence that changes the decision Choose it when
System.Text.Json Issue #6 reports native STJ excluding the configured property and rejecting the missing argument, while the preview adapter did neither. Contract comparison Contract and validation settings are application requirements.
System.Text.Json with custom converters Issue #7 reports lower managed allocations for its 1,000-row Guid/TimeSpan workload. Allocation comparison Existing converters and allocation pressure define the workload.
Framework DataContractJsonSerializer Issue #2 uses it as the reference for date providers and parsing styles. Date-settings comparison Those framework semantics define the required behavior.
Newtonsoft.Json Issue #1 names it as the expected-behavior reference for Microsoft JSON dates. Date-offset comparison Existing date conversion defines the compatibility target.

CAPCOM's REDox is the .NET library covered here

CAPCOM-TD-OSS/REDox and its CAPCOM.REDox packages identify this review's subject. The supplied chemistry page, Redox OS documentation and AWS healthcare case study describe different entities. They provide no adapter-migration comparison for this repository. Naming the repository and package avoids importing their capabilities or customer results into a decision about CAPCOM's library. REDox package identity

Questions people ask

Keep native System.Text.Json when contract customization or required-constructor validation is essential; issue #6 reports both diverging through the preview adapter. That recommendation follows the reporter's two concrete outcomes: an excluded property appeared in output, and a missing required constructor argument was accepted. The questions below address the settings, allocations and culture behavior raised in the supplied issue evidence. Issue #6 compatibility report

Does REDox honor System.Text.Json contract customization and required constructor parameters?

Issue #6 reports ignored TypeInfoResolver customization and RespectRequiredConstructorParameters with CAPCOM.REDox 1.0.3 and the 1.0.3-preview adapter. The reproduction compares the same intended contract behavior through native STJ and REDox, producing different output and rejection behavior. Applications depending on those options have a concrete reason to keep native STJ at that boundary. Reported contract divergence

How much allocation overhead do custom System.Text.Json converters add through REDox?

Issue #7 reports 9.50 times the managed allocations of native System.Text.Json for its 1,000-row Guid/TimeSpan converter workload. Both sides serialized UTF-8 bytes, making the output form explicit. The useful acceptance workload is therefore the adapter with the application's existing converters and target types, rather than a core serializer benchmark selected only because it reports a favorable ratio. Reported converter workload

Does REDox parse TOML floats correctly under comma-decimal cultures such as pt-BR?

The maintainer reported culture-independent numeric and timestamp conversions released in v1.0.1 after issue #3 described culture-dependent parsing. That release statement answers the historical report. For a consuming application, a dot-decimal literal under a comma-decimal process culture is the direct acceptance case because it separates the format's required syntax from the machine's ambient number conventions. TOML culture correction

Can unsupported System.Text.Json settings be detected before REDox processes data?

Issue #6 requests explicit rejection of unsupported non-default settings or a documented capability check. The report describes silent ignoring of the named options rather than an early exception. That distinction matters when designing migration checks: supplying an option and receiving output are separate from obtaining the contract behavior the option requests. The supplied issue is open. Requested capability check

What we have not tested yet

Our run covered the external Go subproject, not installation, building or testing of the main .NET solution. The Compose attempt supplied no application task results or screenshots. Actual runtime and operating-system versions require raw toolchain logs; the configured image label alone supplies neither. We have not reproduced the contributor benchmarks, compatibility examples or README code, and no corrected example is presented as executed here.

Issues #1 and #2 identify fixes intended for a subsequent package update without identifying its released package version. Issue #4's XML/CSV/TOML resolution excludes the deferred experimental YAML behavior. Issue #8 remains an open proposal, so its branch results are not released-package savings. The current README is not an exact-v1.0.3 API snapshot, and cross-format conversion can be a structural projection rather than a lossless semantic round trip.

Issue #7 measures managed bytes per operation, not retained heap, native memory or peak RAM; its timing confidence interval is wide. Issue #8's 10-property timing confidence intervals overlap. These contributor measurements support workload-specific comparisons. Issue #6 uses synthetic data and supplies no evidence of a real application's data leak. The records also supply no sustained-load result, independent security assessment or confirmed production adoption story; issue #3's positive comment expresses future intent.

All four numerical rating dimensions remain unassessed because the supplied work does not support calibrated product scores. The next useful acceptance case is a behavior the consuming application already requires: an excluded property, a required constructor argument or a date conversion. Compare that behavior against the existing serializer with explicit package versions and settings before replacing the boundary.

Alternatives

ProjectWhat it isPick it when
System.Text.JsonThe native serializer used as the comparison in issues #6 and #7.Keep it when the contract exclusions or required-constructor rejection demonstrated in issue #6 are application requirements.
Newtonsoft.JsonThe expected-behavior reference for Microsoft JSON dates in issue #1.Keep it when existing Newtonsoft.Json date conversion defines the required behavior.
DataContractJsonSerializerThe framework serializer used as the date-provider and parsing-style reference in issue #2.Choose it when preserving those framework date semantics is the immediate requirement.

What people are saying

  1. [lobsters] Virtualized Redox: from Virtio-FS to Cloud Hypervisor, and beyond

Sources

  1. REDox README
  2. Issue #1 date-offset report
  3. Issue #2 date-settings report
  4. Issue #3 culture report
  5. Issue #4 parser report
  6. Issue #5 scalar-conversion report
  7. Issue #6 contract report
  8. Issue #7 converter benchmark
  9. Issue #8 dictionary-capacity proposal

More dev tools reviews