home | next
Created: January 2026
Purpose: Complete reference for XBRL specifications and standards
Target Audience: XBRL developers, particularly those updating implementations from 2014-2018
This collection contains many comprehensive markdown documents covering all aspects of XBRL:
- Introduction to XBRL
- Core concepts (facts, instances, taxonomies, contexts)
- Use cases and benefits
- Technical foundation
- Current state as of 2026
Start here if you're new to XBRL or need a refresher.
- Complete catalog of all XBRL specifications
- Organized by functional area
- Status of each specification (REC, CR, PWD)
- Recent releases (2025 updates)
- Notes for Java developers
Use this as your comprehensive reference guide.
- Visual dependency graphs (Mermaid diagrams)
- How specifications relate to each other
- Implementation priority guide
- Testing implications
- External dependencies
Use this to understand the specification ecosystem and plan implementation.
- Deep dive into XBRL 2.1
- Detailed coverage of XBRL Dimensions 1.0
- Complete examples of all features
- Taxonomy structure
- Linkbase types
Use this for detailed technical understanding of core XBRL.
- xBRL-XML format (traditional)
- Inline XBRL (iXBRL) format
- xBRL-JSON format (modern)
- xBRL-CSV format (bulk data)
- Format comparison and selection guide
Use this to choose and implement appropriate data formats.
- Validation layers (XML → Schema → XBRL → Calculations → Formula)
- Calculation validation
- Formula specification details
- Variables, filters, and assertions
- Best practices
Use this to implement comprehensive validation.
- Major additions since December 2016 (GLOMIDCO development stopped December 2016 and has been r3estarted recently)
- Open Information Model (critical update)
- Migration guide from 2014-2016 codebase
- Implementation roadmap
- Priority recommendations
Start here if updating an existing GLOMIDCO XBRL processor from 2014-2016.
- XPath requirements for XBRL
- Why Saxon is essential for Formula
- Saxon editions comparison (HE/PE/EE)
- Licensing considerations
- Integration examples
- Alternatives analysis (and why they don't work)
- Cost analysis and recommendations
Essential reading if implementing Formula validation or questioning Saxon dependency.
- Taxonomy Package specification (evolution from v1.0.2 to 1.0)
- Report Package specification (new in 2025)
- Package structure and metadata formats
- taxonomyPackage.xml and reportPackage.json
- URL remapping with catalog.xml
- Entry points explained in detail
- Java implementation examples
- Migration guide from old formats
- Creating and validating packages
Essential reading for implementing taxonomy distribution and report packaging features.
- What conformance suites are and why they matter
- Complete list of 20+ available conformance suites
- Test case structure and formats
- Java test harness implementation
- Automated testing strategies
- CI/CD integration examples
- Test prioritization and scheduling
- Debugging failed tests
- Where to obtain suites (membership required)
- Best practices for systematic testing
Essential reading for ensuring your processor meets XBRL standards and passes certification.
- The fundamental distinction between metadata (taxonomy) and data (instance)
- Why .xml files can be metadata in XBRL (linkbases)
- File extension meanings: .xsd + .xml = taxonomy, .xbrl = instance
- The role of XLink and XPointer in taxonomies
- How xBRL-JSON and xBRL-CSV relate to taxonomies
- Comparison with traditional XML, JSON Schema, and CSV standards
- The Open Information Model (OIM) abstraction
- Common misunderstandings and how to avoid them
- Java implementation for file type identification
- Complete decision trees and examples
Essential reading for understanding XBRL's architecture - addresses the #1 source of confusion in XBRL.
- Why traditional DOM approaches fail catastrophically with XBRL
- Memory explosion analysis (2-4 GB per instance with naive approach)
- The three-phase architecture: Design Time, Init Time, Runtime
- How entry point selection reduces memory by 50-80%
- Optimized internal memory model design
- Straight-Through Processing (STP) implementation
- Real-world performance benchmarks (80-95% memory savings)
- GLOMIDCO processor architecture explained
- Memory optimization techniques
- Detailed implementation examples with Java code
Essential reading for building production-grade XBRL processors that can handle high volumes efficiently.
- COREP and FINREP European banking regulatory reporting explained
- Why COREP/FINREP is exceptionally challenging (60+ templates, Table Linkbase)
- Traditional Data Point Model (DPM) approach and its limitations
- GLOMIDCO's middleware-based solution (MuleSoft, Tibco BW, webMethods)
- Distributed mapping pattern - independent template generation
- Intelligent merging and validation strategy
- Conflict detection and resolution
- Parallel processing for 60+ templates
- Real-world comparison: DPM vs middleware approach
- Team ownership and maintainability benefits
- Complete implementation examples
Essential reading for regulatory reporting architects and anyone implementing complex XBRL solutions with multiple tables.
- Why XBRL fundamentally requires mapping (bidirectional)
- The mapping challenge: business data ≠ XBRL structure
- Design-time schema generation from XBRL taxonomies
- Generating XSD and JSON Schema for middleware tools
- Viewpoint concept: Flat, Table-Oriented, Hierarchical, Dimensional
- Visual mapping in MuleSoft, Tibco BW, and webMethods
- UTL-X functional mapping language (open source)
- Real-world use cases: outbound (generate) and inbound (consume)
- Mapping from SAP/ERP to XBRL regulatory reports
- Consuming XBRL for consolidation and analysis
- Why hand-coding is impractical at scale
Essential reading for anyone implementing XBRL integrations - explains why mapping is the critical missing piece.
- XBRL's built-in versioning capabilities and specifications
- Why taxonomy versioning matters (hundreds of changes per year)
- The Versioning 1.0 specification and report format
- Types of changes tracked: concepts, relationships, labels, references
- Complete version report example (US GAAP 2023 to 2024)
- Automated impact analysis using version reports
- Instance document migration strategies
- Creating version reports (manual and automated)
- Real-world use cases: SEC filing prep, software updates, regulatory communication
- Best practices for taxonomy developers and consumers
Essential reading for managing taxonomy updates and understanding what changed between versions.
- Why taxonomy browsers are essential (packages contain 27+ entry points)
- The complexity of modern taxonomy packages (US GAAP, COREP/FINREP)
- What browsers must display: hierarchies, metadata, descriptions
- Entry point selection challenges and path derivation
- Implementation approaches: Desktop GUI, web-based, CLI, API
- Complete Java Swing and React examples
- Integration with GLOMIDCO design-time schema generation
- Middleware configuration workflows
- Path resolution for different tools (processor, generator, validator)
- Best practices for user experience and performance
Essential reading for building XBRL tools with user-friendly entry point selection.
- The human readability problem with raw XBRL-XML
- Inline XBRL (iXBRL) specification - the official solution
- How Inline XBRL embeds XBRL in HTML (dual purpose documents)
- Complete Inline XBRL examples with transformation formats
- XBRL viewers: SEC viewer, Arelle, browser-based, desktop
- Open Information Model (OIM) and alternative representations
- xBRL-JSON and xBRL-CSV for human-friendly consumption
- The Dutch experiments and their influence on modern standards
- Implementation guide: converting XBRL-XML to HTML
- Best practices for filing preparers and tool developers
Essential reading for understanding how to make XBRL accessible to humans.
- The WIP problem: XBRL documents created over months by multiple people
- Why file-based approaches fail for collaborative XBRL
- The incompleteness challenge: validating incomplete documents
- Multi-contributor workflows (accountant, tax specialist, auditor, etc.)
- CMIS as OASIS open standard: specification, bindings, and layered architecture
- The three CMIS bindings: AtomPub (REST+XML), SOAP, Browser/JSON
- CMIS layered object model: types, instances, properties, content, versions, ACLs
- CMIS services: 11 standard services including CMIS Query Language (SQL-like)
- GLOMIDCO's CMIS extension for XBRL: custom types and operations
- GLOMIDCO's proven architecture (2014+): BPM + CMIS + ESB
- Multilayered documents with viewpoints and section locking
- BPM workflow integration with complete BPMN 2.0 example
- Multi-binding client examples: Java (AtomPub), C# (SOAP), JavaScript (JSON)
- ESB service layer: validation, signing (XAdES), viewpoint generation
- Progressive validation strategies
- Alternative approaches: Git-based, spreadsheet-based, form-based
- Production implementation lessons learned
Essential reading for implementing collaborative XBRL document creation workflows with CMIS.
- Comprehensive catalog of 40+ XBRL International specifications
- Core specifications: XBRL 2.1, Dimensions 1.0, Formula 1.0 suite, Inline XBRL 1.1
- Extended modules: Table Linkbase, Versioning, Taxonomy Packages, OIM
- Transformation Registry, Extensible Enumerations, Generic Linkbase
- Specialized applications: XBRL GL, Sustainability Reporting, Banking Regulation
- Global XBRL adoption map: 60+ countries with XBRL implementations
- Americas: US (SEC), Canada, Brazil, Mexico, Chile and more
- Europe: EU (ESMA/ESEF, EBA), UK, Netherlands, Germany, France, Spain and more
- Asia-Pacific: China, Japan, South Korea, India, Singapore, Hong Kong and more
- Country-by-country detailed coverage with extensions and requirements
- US SEC: Inline XBRL mandatory, US GAAP taxonomy, DQC rules
- EU ESMA: ESEF filing rules, IFRS taxonomy, anchoring requirements
- EU EBA: COREP/FINREP, Table Linkbase required, DPM validation
- Asian markets: Language support, local taxonomies, filing systems
- Processor implementation priorities (MUST/SHOULD/COULD/MAY)
- Complete implementation checklist for GLOMIDCO processor update
- Testing requirements: conformance suites and real-world test cases
- Performance benchmarks and scalability requirements
- Maintenance strategy for specification and taxonomy updates
- Decision matrix with implementation effort estimates
Essential reading for XBRL processor development and understanding global XBRL requirements.
- The eXtensible promise: XBRL was designed to allow runtime extensions
- Why runtime extensions failed: The Pepsi vs. Coca-Cola problem
- Different companies extend differently (no comparability, no analysis)
- The IT reality: Cannot process unknown metadata at runtime
- The abandoned XBRL 2.2 class concept proposal
- How abstract classes would have solved the extension problem
- Why XBRL 2.2 was abandoned (technical, political, practical)
- Managed extensions: The solution that works (Dutch SBR model)
- SBR success: Review, standardize, incorporate extensions
- The Dutch SBR disaster: Yearly taxonomies with new namespaces
- The "yellow form, purple form" anti-pattern
- €10 billion wasted annually on unchanged forms
- How yearly namespace changes destroy IT investment ROI
- The complete cost breakdown: Direct, indirect, opportunity costs
- XBRL Versioning 1.0: The specification everyone ignores
- When to create new versions vs. keeping stable namespaces
- Semantic versioning for taxonomies (major.minor.patch)
- US GAAP best practices vs. Dutch SBR anti-pattern
- Recommendations for regulators, taxonomy designers, IT implementers
- Call to action: Fix the SBR yearly taxonomy disaster
Essential reading for understanding why unmanaged extensions fail and why namespace stability matters for XBRL adoption.
- The point solution anti-pattern: Spreadsheets and forms that only generate one instance
- Why country-specific solutions don't scale (technical debt disguised as quick wins)
- The spreadsheet trap: VBA string concatenation and hardcoded assumptions
- The form-based trap: Hardcoded for one taxonomy, breaks on updates
- Why generic XBRL processors are essential (multi-jurisdiction, validation, analysis)
- Complete survey of existing processors: Arelle, GLOMIDCO, Semansys, Fujitsu, CoreFiling
- Arelle (Python, open source) - Most complete implementation
- GLOMIDCO (Java, commercial) - Three-phase architecture, production-grade
- Semansys/Visma (C#/.NET) - Romanian mathematics team, strong formulas
- Processor comparison matrix (language, specifications, performance, cost)
- Why building a processor takes 10-50 person-years
- Complexity comparison: XBRL is 10-100x more complex than XML
- The calculation linkbase nightmare (not just a calculator!)
- Real examples: Negative weights, rounding tolerance, circular relationships
- Dimensional explosion: Combinatorial complexity
- Formula evaluation: Computational expense
- Table Linkbase complexity explosion (the HARDEST component!)
- Three-dimensional tables: X-axis, Y-axis, Z-axis filtering
- Recursive breakdown trees (5+ levels deep)
- Open vs. closed axes (dynamic structure at runtime)
- COREP example: 150 rows × 20 columns × 3 filters = thousands of evaluations
- Why Table Linkbase takes 12-16 person-months (most complex XBRL feature)
- The tuple problem (deprecated but required!)
- What tuples are and why they were created
- Why tuples are incompatible with dimensions, formulas, calculations
- Why tuples were deprecated (2010+)
- Why processors must still support tuples (backwards compatibility, conformance)
- Tuple processing adds 3-4 person-months of technical debt
- GLOMIDCO's conformance suite experience (94% pass rate, contradictions, impossibilities)
- Why 100% conformance is impossible (contradictory tests, specification ambiguities)
- Extension validation dilemma (architectural trade-offs)
- Development effort breakdown: 89-131 person-months for complete processor
- Build vs. buy analysis: €2M-3M to build vs. €250k-500k to buy
- Decision matrices for companies, vendors, and architects
Essential reading for understanding XBRL processor complexity and making build-vs-buy decisions.
- The ESG revolution: Environmental, Social, Governance reporting becomes mandatory
- What ESG is: Climate, labor, diversity, ethics, board structure, and more
- Why ESG matters: $35+ trillion in sustainable investments, regulatory mandates
- The ESG data problem: Multiple frameworks (GRI, SASB, TCFD, CDP), no standard (like financial reporting in 2000)
- XBRL's role in ESG standardization
- Key ESG XBRL taxonomies:
- IFRS S1/S2 Sustainability Disclosure Taxonomy (global baseline, climate focus)
- ESRS XBRL Taxonomy (EU mandatory, comprehensive E+S+G)
- GRI XBRL Taxonomy (impact reporting, 13,000+ organizations)
- CDP taxonomy (environmental disclosure, investor-backed)
- SASB standards (now integrated into IFRS S2, industry-specific)
- XBRL Standards Dependencies for ESG (comprehensive table)
- Which XBRL specifications are required vs. optional for ESG
- Core: XBRL 2.1, Dimensions 1.0 (critical!), Taxonomy Packages
- Extended: Inline XBRL, Formula, Versioning, Extensible Enumerations
- Priority implementation sequence (3-phase roadmap)
- ESG-specific considerations (dimensions are critical, calculations less important)
- Dependency breakdown by taxonomy (IFRS S1/S2, ESRS, GRI, CDP)
- Processor selection criteria for ESG implementations
- Technical implementation: Instance structure, dimensions, integration with financial reporting
- ESG data architecture: From energy systems to XBRL output
- Challenges: Data quality, scattered systems, calculation complexity, greenwashing prevention
- XBRL enables: Machine-readable data, comparability, automation, validation, assurance
- Implementation roadmap: 12-18 months, five phases
- Use cases: Companies (50-70% efficiency gains), investors (automated analysis), regulators (oversight)
- Regulatory trends: EU CSRD (50,000+ companies), ISSB adoption (30+ countries), expanding scope
- Future: Biodiversity, water, circular economy, supply chain transparency
- Market impact: ESG becomes mainstream, competitive advantage, cost of capital implications
Essential reading for understanding how XBRL is standardizing ESG/sustainability reporting just as it did for financial reporting.
- How XBRL processors discover and assemble concept information
- The scattered information problem: Data across multiple XML documents
- Explicit traversal: Following schema imports and linkbase references (straightforward)
- Implicit traversal: Following linkbase arcs to discover information (NOT obvious, CRITICAL)
- The Locator → Arc → Resource pattern (core XBRL linking mechanism)
- Why implicit traversal is necessary and why it's not obvious
- Detailed walkthrough: Discovering all information about a concept
- Labels from label linkbase
- References from reference linkbase
- Calculations from calculation linkbase
- Presentations from presentation linkbase
- The circular reference problem: Documents reference each other
- Node structure: Attaching discovered information as child nodes
- When traversal happens: Design-time (entry point load), NOT runtime
- GLOMIDCO implementation: TRAVERSAL_TRACE and TRAVERSAL_ULTRA_TRACE logging
- Complex scenarios: Multi-hop locators, prohibited arcs, dimensional complexity
- Common pitfalls: Forgetting implicit traversal, processing order, XPointer resolution
- Performance optimization: Lazy traversal, caching, parallel processing
- Testing: Completeness tests, locator resolution tests, arc following tests
- Debugging techniques and visualization tools
- Best practices for traversal architecture
Essential reading for XBRL processor developers - this is the most poorly documented but critical aspect of XBRL implementation.
- How XBRL processors generate XSD schemas for fast instance validation
- The performance problem: Runtime taxonomy validation is slow (5-11 seconds per instance)
- The solution: Generate consolidated XSD at design-time, validate at runtime (0.65-1.3 seconds)
- Two-phase validation model: Design-time generation vs. runtime validation
- Foundation: XBRL instance schema (xbrl-instance-2003-12-31.xsd)
- Generation process: Extract root concepts from presentation linkbase
- Algorithm: Generate elements, add children recursively, apply constraints
- Handling dimensions: Segment vs. scenario (GLOMIDCO preference: scenario)
- Why dimensions can't be in XSD: Validation requires DTS, not XSD
- GLOMIDCO law system: TaxonomyLaws.xml and ReportingLaws.xml
- Taxonomy laws: AllowExtensions, DimensionLocation, RequireCalculationLinkbase
- Reporting laws: RequiredContexts, MaximumFileSize, MandatorySignature
- Empty value handling:
<value> </value> means "do nothing"
- Override mechanism: TRUE/FALSE to override defaults
- Taxonomy package structure (ZIP):
- META-INF/catalog.xml: OASIS XML Catalog redirections
- META-INF/taxonomyPackage.xml: XBRL standard entry point definitions
- META-INF/TaxonomyLaws.xml: GLOMIDCO standard taxonomy constraints
- META-INF/ReportingLaws.xml: GLOMIDCO standard instance constraints
- FRTA and NL-FRIS rules integration
- Runtime validation: Two-stage (XSD validation + XBRL validation)
- Performance benefits: 5-10x speedup (1.4-3 hours → 11-22 minutes for 1,000 instances)
- Tables limitation: Not yet worked out (TODO in GLOMIDCO)
- Best practices for schema generation and law management
Essential reading for understanding how XBRL processors achieve fast instance validation through design-time schema generation.
- GLOMIDCO's internal data structure for representing the DTS (Discoverable Taxonomy Set)
- Source: GLOMIDCO development notes, December 2016, Section 4
- The representation challenge: Many XBRL element types (concepts, labels, references, hypercubes, dimensions)
- Traditional approach vs. GLOMIDCO approach: Separate classes vs. unified Node
- Unified Node structure: Single class that can represent ANY XBRL element
- NodeType enum: CONCEPT, LABEL, REFERENCE, HYPERCUBE, DIMENSION, ROLE_TYPE, RESOURCE, TUPLE
- Generic property storage: Map<String, Object> for type-specific data
- Connection objects: Represent all relationships (arcs)
- Multi-dimensional maps: Fast O(1) lookups from any perspective
- Index by URI
- Index by QName
- Index by NodeType
- Index by Role
- Hierarchy: Role → Linkbase → Node → Connections
- Important: "Node" is GLOMIDCO internal term, NOT XBRL specification term
- Tuples as concepts: Treated as NodeType for backward compatibility
- Resource nodes: Can contain custom XML fragments for validation
- Complete architecture: DTS, Role, Linkbase, Node, Connection classes
- Building the DTS: Three-phase process (load documents, create nodes, process linkbases)
- Performance characteristics: ~40% memory savings, O(1) lookups, multi-dimensional index trade-offs
- Usage patterns: Finding concepts, traversing relationships, getting labels
- Advantages: Flexibility, memory efficiency, unified relationship model, fast lookups
- Trade-offs: Type safety (runtime checks), memory overhead (indexes), complexity
Essential reading for understanding GLOMIDCO's sophisticated internal architecture and design decisions.
- Read: 07-XBRL-Changes-Since-2016 (critical changes)
- Review: 03-XBRL-Dependency-Map (implementation priorities)
- Deep dive: 05-XBRL-Data-Formats (OIM, JSON, CSV)
- Read: 01-XBRL-Overview (introduction)
- Read: 04-XBRL-Core-Specifications (foundation)
- Browse: 02-XBRL-Specifications-Catalog (complete picture)
- Read: 05-XBRL-Data-Formats (format guide)
- Review: 03-XBRL-Dependency-Map (dependencies)
- Read: 06-XBRL-Validation (validation guide)
- Review: 04-XBRL-Core-Specifications (core semantics)
- Check: 08-XBRL-XPath-and-Saxon (if implementing Formula)
- Read: 08-XBRL-XPath-and-Saxon (comprehensive answer)
- Short answer: For full Formula support, Saxon is effectively required
¶ "How do I handle taxonomy distribution?"
- Read: 09-XBRL-Taxonomy-and-Report-Packages (complete guide)
- Covers both Taxonomy Packages and Report Packages (new 2025)
- Read: 10-XBRL-Conformance-Suites-and-Testing (comprehensive testing guide)
- Covers all conformance suites, test harness implementation, and best practices
- Read: 11-XBRL-Metadata-vs-Data-Architecture (THE MOST IMPORTANT CONCEPT)
- Explains metadata vs data, file extensions, XLink, and common misunderstandings
- Start here if you're new to XBRL architecture
- Read: 12-XBRL-Memory-Challenges-and-Architecture (CRITICAL FOR PRODUCTION)
- Explains why DOM fails, three-phase architecture, and memory optimization
- Essential for building high-performance processors
¶ "How do I handle COREP/FINREP regulatory reporting?"
- Read: 13-COREP-FINREP-and-Middleware-Approach (REAL-WORLD USE CASE)
- Explains 60+ table complexity, DPM limitations, and distributed middleware solution
- Essential for regulatory reporting implementations
¶ "How do I map between business systems and XBRL?"
- Read: 14-XBRL-Mapping-and-Schema-Generation (THE CRITICAL MISSING PIECE)
- Explains design-time schema generation, viewpoints, and UTL-X
- Essential for ALL XBRL integrations - both generating and consuming XBRL
¶ "How do I handle taxonomy version updates?"
- Read: 15-XBRL-Taxonomy-Versioning (CHANGE MANAGEMENT)
- Explains XBRL's built-in versioning capabilities and migration strategies
- Essential for managing taxonomy updates and understanding changes
- Read: 16-Taxonomy-Browsers-and-Entry-Point-Selection (USER INTERFACE)
- Explains why browsers are essential and how to implement them
- Essential for building user-friendly XBRL tools
- Read: 17-Human-Readable-XBRL-Inline-and-Viewers (HUMAN CONSUMPTION)
- Explains Inline XBRL, viewers, and the OIM
- Essential for making XBRL accessible to non-technical users
¶ "How do I handle collaborative XBRL document creation?"
- Read: 18-XBRL-Work-in-Progress-Collaborative-Creation (WORKFLOWS)
- Explains WIP challenges and GLOMIDCO's BPM/CMIS/ESB architecture
- Essential for multi-person, multi-month XBRL document creation
- Read: 19-Complete-XBRL-Specifications-Catalog (GLOBAL REQUIREMENTS)
- Comprehensive catalog of 40+ specs and 60+ country implementations
- Essential for processor development and global XBRL compliance
¶ "Why do extensions and taxonomy versioning matter?"
- Read: 20-XBRL-Extensions-and-Versioning-Reality (EXTENSIONS & VERSIONING)
- Explains the eXtensible promise, why runtime extensions failed, and SBR versioning issues
- Essential for understanding taxonomy management and avoiding versioning disasters
- Read: 21-Why-Generic-XBRL-Processors-Matter (PROCESSOR COMPLEXITY)
- Explains why spreadsheet solutions fail, processor comparison, and build-vs-buy analysis
- Essential for making informed decisions about XBRL infrastructure
¶ "What about ESG and sustainability reporting?"
- Read: 22-ESG-Sustainability-and-XBRL (ESG & SUSTAINABILITY)
- Explains ESG revolution, XBRL taxonomies (IFRS S1/S2, ESRS, GRI), and implementation
- Essential for understanding how XBRL is standardizing ESG reporting
- Read: 23-XBRL-Taxonomy-Traversal (TRAVERSAL)
- Explains explicit and implicit traversal, locator-arc-resource pattern, and node assembly
- Essential for understanding how XBRL processors discover and assemble concept information
- Read: 24-Design-Time-XSD-Generation (XSD GENERATION)
- Explains schema generation from presentation linkbase, law system, and taxonomy packages
- Essential for understanding how XBRL processors achieve fast instance validation
- Read: 25-GLOMIDCO-DTS-Core-Structure (DTS ARCHITECTURE)
- Explains unified Node structure, multi-dimensional maps, and relationship management
- Essential for understanding GLOMIDCO's sophisticated internal data structure
- Read: 26-Dutch-SBR-XBRL-Dependencies (DUTCH SBR DEPENDENCIES)
- Complete overview of all 17+ specifications used by Dutch government reporting
- Essential for implementing Dutch SBR support or understanding real-world XBRL complexity
- Read: 27-XBRL-Global-Adoption-World-Map (GLOBAL XBRL ADOPTION MAP)
- Comprehensive world map with 60+ countries and detailed country profiles
- Essential for understanding global adoption, planning international implementations, or comparing country approaches
Read documents in order: 01 → 02 → 03 → 04 → 05 → 06 → 07 → 08 → 09 → 10 → 11 → 12 → 13 → 14 → 15 → 16 → 17 → 18 → 19 → 20 → 21 → 22 → 23 → 24 → 25
Or read 11 first if confused about basic XBRL architecture!
Or read 12 first if building a production processor!
Or read 13 first if implementing regulatory reporting!
Or read 14 first if integrating XBRL with business systems!
Or read 15 first if dealing with taxonomy updates!
Or read 16 first if building taxonomy selection UIs!
Or read 17 first if making XBRL human-readable!
Or read 18 first if implementing collaborative workflows!
Or read 19 first if updating an XBRL processor!
Or read 20 first if dealing with extensions or taxonomy versioning!
Or read 21 first if evaluating point solutions vs. generic processors!
Or read 22 first if implementing ESG/sustainability reporting!
Or read 23 first if building an XBRL processor and need to understand traversal!
Or read 24 first if implementing fast instance validation with generated schemas!
Or read 25 first if understanding GLOMIDCO's internal DTS data structure!
Document 03-XBRL-Dependency-Map.md includes Mermaid diagrams showing:
- Foundation dependencies
- Format dependencies
- Validation dependencies
- Complete ecosystem map
To view: Use a Markdown viewer that supports Mermaid (GitHub, VS Code with extensions, etc.)
- Open Information Model (2021) - Syntax-independent core model
- xBRL-JSON (2021) - JSON format for XBRL
- xBRL-CSV (2021) - CSV format for bulk data
- Extensible Enumerations 2.0 (2020) - Enhanced enumerations
- Report Packages 1.0 (2025) - Report distribution
- Calculations 2.0 (2018) - Enhanced calculation validation
- XBRL 2.1 remains stable (stability pledge)
- Dimensions 1.0 remains stable
- All your 2014-2018 knowledge is still valid!
Based on the analysis, if you're updating from 2014-2018:
- ✅ Update to latest XBRL 2.1 conformance suite (2025)
- ✅ Update to latest Dimensions conformance suite (2025)
- 🆕 Implement Open Information Model (OIM) core
- 🆕 Add xBRL-JSON support
- 🆕 Add xBRL-CSV support
- 🆕 Implement Extensible Enumerations 2.0
- 🆕 Implement Calculations 2.0
- ✅ Update Formula implementation (if you have it)
- 🆕 Add Report Packages support
- 🔄 Modernize Java APIs
- 🔜 Monitor Digital Signatures (under development)
- 🔜 Monitor Streaming Extensions (under development)
Estimated Total Effort: 8-12 months for comprehensive update
- ✅ = Update existing implementation
- 🆕 = New specification to add
- 🔜 = Future consideration
- 🔄 = Refactor/modernize
- ❌ = Not recommended/deprecated
- REC = Recommendation (stable, approved)
- CR = Candidate Recommendation (ready for testing)
- PWD = Public Working Draft (in development)
- REQ = Requirements document
- All documents use Markdown
- Code examples in XML, JSON, or CSV
- Mermaid diagrams for visualizations
- Tables for comparisons
Total: ~990 KB of comprehensive documentation
- ✅ All current specifications covered
- ✅ All data formats explained
- ✅ Complete validation guide
- ✅ Migration guide for 2014-2016 codebases (GLOMIDCO development stopped December 2016)
- ✅ Implementation priorities
- ✅ Visual dependency maps
- ✅ Code examples throughout
- ✅ XPath/Saxon requirements and alternatives analyzed
- ✅ Taxonomy and Report Package specifications (including evolution)
- ✅ Comprehensive conformance testing guide (20+ test suites)
- ✅ Metadata vs Data architecture explained (addresses #1 confusion in XBRL)
- ✅ Memory optimization and three-phase architecture (production-grade performance)
- ✅ COREP/FINREP regulatory reporting solution (real-world use case with 60+ tables)
- ✅ Design-time schema generation and mapping (bidirectional integration with business systems)
- ✅ Taxonomy versioning and change management (built-in XBRL capabilities)
- ✅ Taxonomy browsers for entry point selection (user-friendly navigation)
- ✅ Human-readable XBRL with Inline XBRL and viewers (making XBRL accessible)
- ✅ Collaborative XBRL creation with WIP workflows (BPM/CMIS/ESB architecture)
- ✅ Complete specifications catalog (40+ specs, 60+ countries, processor requirements)
- ✅ Extension management and versioning reality (why unmanaged extensions fail, Dutch SBR issues)
- ✅ Generic processor importance (point solution anti-patterns, processor survey, complexity analysis)
- ✅ ESG and sustainability reporting (IFRS S1/S2, ESRS, GRI, implementation roadmap)
- ✅ Taxonomy traversal mechanics (explicit and implicit traversal, locator-arc-resource pattern)
- ✅ Design-time XSD generation (fast validation, law system, taxonomy packages, META-INF structure)
- ✅ GLOMIDCO DTS core structure (unified Node, multi-dimensional maps, Connection model)
- Read Overview
- Skim Specifications Catalog
- Review Core Specifications basics
- Deep dive Core Specifications
- Study Data Formats
- Understand Dependencies
- Master Validation
- Plan Migration Strategy
- Review all specifications in detail
- Follow roadmap in Changes Since 2018
- Implement incrementally
- Test with conformance suites
¶ 📝 Updates and Maintenance
This documentation reflects the state of XBRL as of January 2026.
- New specification releases
- Status changes (CR → REC)
- Emerging specifications
- Conformance suite updates
This documentation was created as a comprehensive starting point for XBRL understanding.
For the most current information:
- Always check official XBRL International sources
- Participate in XBRL International working groups
- Join jurisdiction-specific user groups
- Consult the community forums
Each document includes:
- Clear purpose statement
- Target audience
- Comprehensive content
- Practical examples
- Cross-references to other documents
- Next steps guidance
- XBRL is stable - Core specs (2.1, Dimensions) haven't changed
- New formats added - JSON and CSV join XML and Inline
- OIM is the future - Syntax-independent model enables interoperability
- Your knowledge is valid - 2014-2018 foundation still applies
- Incremental adoption - Can implement new features gradually
For implementation questions:
- Review the official XBRL documentation
- Check the specifications site
- Consult reference implementations (Arelle)
- Join XBRL International community
- Contact jurisdiction-specific support
Updating from 2014-2016? Use this checklist:
This documentation collection provides:
- ✅ Complete overview of XBRL
- ✅ All specifications catalogued
- ✅ Clear dependency relationships
- ✅ Detailed technical guides
- ✅ Format comparison and selection
- ✅ Comprehensive validation guide
- ✅ Migration path from 2014-2018
You now have everything needed to understand and implement modern XBRL!
Last Updated: January 6, 2026
XBRL International: https://www.xbrl.org