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.


