Markdown Elements Showcase

This post demonstrates every supported content element in this custom theme.

Inline Formatting

Standard markdown inline elements are fully supported with cyberpunk-themed styling:

• Bold text renders in bright white for emphasis
• Italic text renders in a subdued tone for nuance
• Strikethrough renders with reduced opacity and a line-through
• Inline code renders with a bordered box and primary color
• Links render with an underline-on-hover effect
• Highlighted text renders with a translucent white background
• Combined: bold with inline code and italic with strikethrough

Headings

All heading levels use the Rajdhani display font, uppercase, with wide letter spacing.

Third Level Heading

Content under a third-level heading. These are useful for subsections within a major topic.

Fourth Level Heading

Fourth-level headings are slightly smaller and dimmer, used for fine-grained organization.

Blockquotes

Standard blockquotes receive decorative dots at the top and bottom left corners, with a 2px primary-colored left border:

At sufficient scale, the distinction between designed and emergent behavior dissolves. The network becomes its own author.

Blockquotes with attribution can be written with a citation line:

The collision of the bleeding edge and the crumbling past has become the defining visual language of our decade.

— Architectural Review, Vol. 892

Nested blockquotes:

First level of quotation

Second level — deeper context or a quote within a quote

Callouts (MDX Components)

Use the Callout component with five severity types:

Custom titles are supported:

In standard .md files, you can also use the > [!NOTE] GitHub-style alert syntax — see the Markdown Syntax Reference post.

Code Blocks

Fenced code blocks are syntax-highlighted by Shiki with the github-dark-default theme, wrapped in a bordered container with a bottom accent gradient:

fn observe_emergence(network: &MeshNetwork) -> Pattern {
    let nodes = network.active_nodes();
    let flows = trace_information_paths(&nodes);

    // Patterns not present in any single node's ruleset
    let emergent = flows
        .cluster(ClusterMethod::Spectral)
        .filter(|p| !p.matches_designed_behavior())
        .collect();

    Pattern::from_clusters(emergent)
}

Use the CodeHeader component to add a filename header:

class SyntheticMemory:
    def decay(self, memory_node: MemoryNode) -> float:
        """Calculate memory retention probability."""
        age = time.now() - memory_node.created_at
        relevance = self.compute_relevance(memory_node)
        emotional_weight = memory_node.affect_score

        half_life = BASE_HALF_LIFE * relevance * emotional_weight
        return math.exp(-DECAY_CONSTANT * age / half_life)

interface Perception {
  source: SensoryChannel;
  timestamp: number;
  confidence: number;
  verified: boolean;
}

function validateExperience(input: Perception): boolean {
  const integrity = checkSourceIntegrity(input.source);
  const temporal = verifyTemporalConsistency(input.timestamp);
  const cross_ref = crossReferenceMemory(input);

  // Trust nothing. Verify everything.
  return integrity && temporal && cross_ref.confidence > 0.7;
}

Inline code in context: Use spectral clustering on traffic flow data to observe patterns above the 10K node threshold.

Tables

Tables render with uppercase headers, hover states on rows, and a subtle border system:

A second table example:

Unordered Lists

Unordered lists use the ▸ marker in primary color:

• Mutation tracking via consensus diff analysis
• Population genetics models applied to node clusters
• Evolutionary pressure from network congestion events
• Speciation events when protocol forks occur naturally

Nested list example:

• Top-level item one
  • Nested sub-item
  • Another nested sub-item
• Top-level item two
  • Sub-item with bold and code

Ordered Lists

Ordered lists use zero-padded numbering (01., 02., etc.):

1. Define boundary conditions, not behaviors
2. Implement feedback loops instead of control flows
3. Monitor for emergence rather than enforce compliance
4. Accept non-determinism as a feature, not a bug

Task Lists (GFM Syntax)

Standard GFM task lists with checkbox styling:

• Deploy monitoring mesh across all target nodes
• Calibrate spectral analysis baselines
• Run 72-hour pre-observation to establish null behavior
• Begin emergent pattern capture with temporal resolution under 100ms
• Cross-reference with known intended behaviors
• Submit findings to peer review network

Task Lists (MDX Component)

For richer control in .mdx files, use the TaskList component:

Definition Lists

Use the DefinitionList MDX component for term-definition pairs:

Strong Emergence

Properties that cannot be derived from complete knowledge of the system's components. Controversial in philosophy of science.

Weak Emergence

Properties that are unexpected but theoretically derivable from component behavior. Most network emergence falls here.

Downward Causation

When emergent properties causally affect the components that produce them — a feedback loop between scales.

Images

Standard markdown images receive grayscale + contrast filters with a hover-to-reveal-color effect:

Image with HUD Corners (MDX)

For the full HUD aesthetic with corner brackets, scanline overlay, and captions, use the ImageFigure component:

Horizontal Rules & Dividers

Standard markdown horizontal rules:

In MDX, use the HudDivider component for a themed separator with diamond markers:

Footnotes

Footnotes use standard GFM syntax — reference them inline with [^n] and define them anywhere in the document:

The concept of emergence has been studied extensively in network theory¹, with practical applications appearing in self-healing mesh architectures². Some researchers argue that sufficiently large networks exhibit properties indistinguishable from biological neural systems³.

Highlighted Text

Use ==double equals== to create highlighted text that renders with a translucent white background. This is useful for drawing attention to key terms or critical concepts within body text.

Combined Elements

Here's an example combining multiple elements in natural flow:

The concept of substrate-independent consciousness has gained traction since the publication of Tanaka's seminal paper. Her framework proposes three key criteria:

1. Self-referential processing — the system must model itself
2. Temporal binding — experiences must cohere across time
3. Intentional states — the system must exhibit aboutness

If consciousness is substrate-independent, then the medium is truly irrelevant — only the pattern matters.

def test_substrate_independence(system: CognitiveSystem) -> bool:
    """Evaluate whether a system meets Tanaka's criteria."""
    return all([
        system.has_self_model(),
        system.temporal_coherence > THRESHOLD,
        system.exhibits_intentionality(),
    ])

Hard Problem

The question of why physical processes give rise to subjective experience (qualia). Coined by David Chalmers in 1995.

Substrate Independence

The hypothesis that consciousness is a pattern that can exist in any sufficiently complex information-processing medium.

This concludes the element showcase. Every component demonstrated here is available for use in your Neural.Log transmissions.