The SDoc markup language is a hybrid format inspired by TOML, YAML, ASN.1, and HTML/XML, designed specifically for structuring technical documents with large volumes of requirements. It aims to encode documents that span up to several hundred or even a few thousand A4-printed pages, while keeping the markup noise minimal to maintain readability. The format supports both shallow and deeply nested document structures, accommodating up to 9-10 levels of chapter nesting, and allows for multiple meta-information fields around each requirement.

StrictDoc's static HTML export feature allows users to generate comprehensive documentation from .sdoc files into a well-structured HTML format. It leverages an efficient in-memory representation of document trees, supporting large-scale documents with thousands of requirements while maintaining decent performance.

The HTML output preserves the hierarchy of requirements, including parent-child relationships, to facilitate traceability and coverage analysis.

Additionally, StrictDoc's incremental generation mechanism ensures quick updates by only regenerating modified documents, enabling efficient handling of extensive requirements specifications.

StrictDoc features an editable web interface that enables users to view and modify requirements directly within their browser. This interface provides a user-friendly way to interact with .sdoc files, allowing real-time editing of documents and requirements. Changes made through the web interface are automatically saved back to the original text files, ensuring synchronization between the user interface and the underlying document structure. The web interface also supports visualization of requirement hierarchies and relationships, making it easier to manage complex documents with multiple nested levels and linked requirements.

StrictDoc supports traceability between requirements and source code, enabling the creation of links from requirements specified in .sdoc files to relevant source code files. This feature ensures that each requirement is adequately addressed in the implementation by associating it with corresponding segments of the codebase. Traceability links are defined using custom references, allowing teams to track which parts of the code fulfill specific requirements. This capability is essential for compliance, validation, and maintaining consistency between documentation and actual implementation. These connections can be visualized in the generated HTML exports, providing a clear and navigable overview of the relationship between requirements and the codebase​.

The "Document grammar" feature allows users to extend the default grammar to fit specific project needs, particularly useful for industries with specialized requirements documentation, such as automotive or aerospace. This feature supports defining custom fields like "PRIORITY," "VERIFICATION," or domain-specific tags like "ASIL" for automotive safety standards. Custom grammars are declared at the document level using the [GRAMMAR] directive, enabling users to specify custom fields and their data types, such as String, SingleChoice, MultipleChoice. These fields can be marked as mandatory, ensuring consistency across requirements documents.

The "Composable Documents" feature in StrictDoc enables users to create composite documents made up of smaller, independent SDoc documents. This modular approach allows each document fragment to be managed separately, which is particularly useful when dealing with large, complex requirements documents.

The "Export to RST" feature in StrictDoc allows users to convert their SDoc documentation into reStructuredText (RST) format, which is compatible with Sphinx documentation generator. This process enables a two-stage conversion workflow where SDoc documents can first be exported to RST and then further processed by Sphinx to generate HTML websites, PDF documents, or other formats. This feature is particularly useful for users who already have a Sphinx-based documentation pipeline, as it integrates StrictDoc’s requirements management capabilities with Sphinx.

The HTML2PDF feature in StrictDoc enables web-based printing to PDF by leveraging ChromeDriver and Google Chrome. This approach uses the Selenium Python library to automate the printing of HTML content directly to PDF format, ensuring that the final document mirrors the exact HTML content rendered in the browser.

The feature allows the user to export content to PDF via a web interface or through a command-line interface. This ensures that the output closely resembles the web page, with no need for additional formatting or adjustments to the content.

The "Query Engine and Search Screen" feature in StrictDoc offers tools for searching and filtering requirements within documents. It uses a Python-inspired syntax to perform complex queries on the document tree, allowing users to find specific sections or requirements based on attributes like titles, parent-child relationships, or custom fields. The search screen is integrated into the web interface, where users can craft queries with logical operators (e.g., AND, OR) and attribute filters (e.g., node.is_requirement).

The "Project Statistics" feature in StrictDoc provides insights into the overall status and details of a documentation project. It offers statistical data that can include information about requirements, document structure, and coverage.

The "Documentation diff/changelog" feature in StrictDoc allows users to track and compare changes made between different versions of project documentation. This feature can highlight modifications at a granular level, such as added, deleted, or altered content within the document.

The ReqIF support feature in StrictDoc allows for both importing and exporting to the ReqIF format, facilitating interoperability with other requirements management tools.

ReqIF is a widely used XML-based standard for requirements data exchange. The import flow allows ReqIF files to be converted into SDoc documents, while the export flow enables SDoc content to be converted back into ReqIF format.

The implementation of ReqIF support is tool-specific due to the flexibility of the ReqIF standard. Different tools may structure and name their fields differently, which means the export/import workflows may require adjustments depending on the tools involved. StrictDoc provides its own model for converting between ReqIF and SDoc, making it adaptable for specific use cases while striving for compatibility with the ReqIF format recommended by the ReqIF Implementation Guide​.

The "strictdoc.toml" file is a project-level configuration file used in StrictDoc to manage various project settings. This configuration file allows customization for features such as selected functionalities, document paths, source file paths, etc.

Key options in the "strictdoc.toml" file include:

• Project title: Defines a project title.
• Feature selection: Selects additional features to activate or deactivate, such as traceability features or experimental tools.
• Paths customization: cache dir, asset dir, document include/exclude paths, source file include/exclude paths, etc.

This configuration ensures that StrictDoc works according to the specific needs of a given project, making it more flexible and adaptable​.