diff --git a/build/jupyterize/QUICKSTART.md b/build/jupyterize/QUICKSTART.md
new file mode 100644
index 000000000..9ea119883
--- /dev/null
+++ b/build/jupyterize/QUICKSTART.md
@@ -0,0 +1,94 @@
+# Jupyterize - Quick Start Guide
+
+## Installation
+
+```bash
+pip install nbformat
+```
+
+## Basic Usage
+
+```bash
+# Convert a file (creates example.ipynb)
+python build/jupyterize/jupyterize.py example.py
+
+# Specify output location
+python build/jupyterize/jupyterize.py example.py -o notebooks/example.ipynb
+
+# Enable verbose logging
+python build/jupyterize/jupyterize.py example.py -v
+```
+
+## What It Does
+
+Converts code example files → Jupyter notebooks (`.ipynb`)
+
+**Automatic:**
+- ✅ Detects language from file extension
+- ✅ Selects appropriate Jupyter kernel
+- ✅ Excludes `EXAMPLE:` and `BINDER_ID` markers
+- ✅ Includes code in `HIDE_START`/`HIDE_END` blocks
+- ✅ Excludes code in `REMOVE_START`/`REMOVE_END` blocks
+- ✅ Creates separate cells for each `STEP_START`/`STEP_END` block
+
+## Supported Languages
+
+| Extension | Language   | Kernel       |
+|-----------|------------|--------------|
+| `.py`     | Python     | python3      |
+| `.js`     | JavaScript | javascript   |
+| `.go`     | Go         | gophernotes  |
+| `.cs`     | C#         | csharp       |
+| `.java`   | Java       | java         |
+| `.php`    | PHP        | php          |
+| `.rs`     | Rust       | rust         |
+
+## Input File Format
+
+```python
+# EXAMPLE: example_id
+# BINDER_ID optional-binder-id
+import redis
+
+# STEP_START connect
+r = redis.Redis()
+# STEP_END
+
+# STEP_START set_get
+r.set('foo', 'bar')
+r.get('foo')
+# STEP_END
+```
+
+## Output Structure
+
+Creates a Jupyter notebook with:
+- **Preamble cell** - Code before first `STEP_START`
+- **Step cells** - Each `STEP_START`/`STEP_END` block
+- **Kernel metadata** - Automatically set based on language
+- **Step metadata** - Step names stored in cell metadata
+
+## Common Issues
+
+**"Unsupported file extension"**
+→ Use a supported extension (.py, .js, .go, .cs, .java, .php, .rs)
+
+**"File must start with EXAMPLE: marker"**
+→ Add `# EXAMPLE: <id>` (or `//` for JS/Go/etc.) as first line
+
+**"Input file not found"**
+→ Check file path is correct
+
+## Testing
+
+```bash
+# Run automated tests
+python build/jupyterize/test_jupyterize.py
+```
+
+## More Information
+
+- **User Guide**: `build/jupyterize/README.md`
+- **Technical Spec**: `build/jupyterize/SPECIFICATION.md`
+- **Implementation**: `build/jupyterize/IMPLEMENTATION.md`
+
diff --git a/build/jupyterize/README.md b/build/jupyterize/README.md
new file mode 100644
index 000000000..8c1dfcd88
--- /dev/null
+++ b/build/jupyterize/README.md
@@ -0,0 +1,338 @@
+# Jupyterize - Code Example to Jupyter Notebook Converter
+
+## Overview
+
+`jupyterize` is a command-line tool that converts code example files into Jupyter notebook (`.ipynb`) files. It processes source code files that use special comment markers to delimit logical steps, converting each step into a separate cell in the generated notebook.
+
+This tool is designed to work with the Redis documentation code example format (documented in `build/tcedocs/`) but can be extended to support other formats.
+
+**Key Features:**
+- **Automatic language detection**: Detects programming language and Jupyter kernel from file extension
+- **Smart marker processing**: Automatically handles HIDE, REMOVE, and metadata markers with sensible defaults
+- **Multi-language support**: Works with any programming language supported by Jupyter kernels
+- **Simple interface**: Minimal configuration required - just point it at a file
+
+## Purpose
+
+The tool enables:
+- **Interactive documentation**: Convert static code examples into executable Jupyter notebooks
+- **Multi-language support**: Generate notebooks for any programming language supported by Jupyter kernels
+- **Step-by-step execution**: Each `STEP_START`/`STEP_END` block becomes a separate notebook cell
+- **Automated workflow**: Batch convert multiple examples for documentation or educational purposes
+
+## Installation
+
+### Requirements
+
+- Python 3.7 or higher
+- Required Python packages (install via pip):
+  ```bash
+  pip install nbformat
+  ```
+
+### Optional Dependencies
+
+For enhanced functionality:
+- `jupyter` - To run and test generated notebooks locally
+- `jupyterlab` - For a modern notebook interface
+
+## Usage
+
+### Basic Command-Line Syntax
+
+```bash
+python jupyterize.py <input_file> [options]
+```
+
+### Options
+
+- `-o, --output <file>` - Output notebook file path (default: same name as input with `.ipynb` extension)
+- `-v, --verbose` - Enable verbose logging
+- `-h, --help` - Show help message
+
+### Automatic Behavior
+
+The tool automatically handles the following without requiring configuration:
+
+- **Language and kernel detection**: Determined from file extension (`.py` → Python/python3, `.js` → JavaScript/javascript, etc.)
+- **Metadata markers**: `EXAMPLE:` and `BINDER_ID` markers are always excluded from notebook output
+- **Hidden blocks**: Code within `HIDE_START`/`HIDE_END` markers is always included in notebooks (these are only hidden in web documentation)
+- **Removed blocks**: Code within `REMOVE_START`/`REMOVE_END` markers is always excluded from notebooks (test boilerplate)
+
+### Examples
+
+**Convert a Python example:**
+```bash
+python jupyterize.py local_examples/client-specific/redis-py/landing.py
+# Output: local_examples/client-specific/redis-py/landing.ipynb
+# Language and kernel auto-detected from .py extension
+```
+
+**Specify output location:**
+```bash
+python jupyterize.py local_examples/client-specific/redis-py/landing.py -o notebooks/landing.ipynb
+```
+
+**Convert a JavaScript example:**
+```bash
+python jupyterize.py examples/example.js
+# Output: examples/example.ipynb
+# Language and kernel auto-detected from .js extension
+```
+
+**Batch convert all Python examples:**
+```bash
+find local_examples -name "*.py" -exec python jupyterize.py {} \;
+```
+
+**Verbose mode for debugging:**
+```bash
+python jupyterize.py example.py -v
+# Shows detected language, kernel, parsed markers, and processing steps
+```
+
+## Input File Format
+
+The tool processes files that follow the Redis documentation code example format. See `build/tcedocs/README.md` for complete documentation.
+
+### Required Markers
+
+**Example ID** (required, must be first line):
+```python
+# EXAMPLE: example_id
+```
+
+### Step Markers
+
+**Step blocks** (optional, creates separate cells):
+```python
+# STEP_START step_name
+# ... code for this step ...
+# STEP_END
+```
+
+- Each `STEP_START`/`STEP_END` block becomes a separate notebook cell
+- Code outside step blocks is placed in a single cell at the beginning
+- Step names are used as cell metadata (can be displayed in notebook UI)
+
+### Optional Markers
+
+**BinderHub ID** (optional, line 2):
+```python
+# BINDER_ID commit_hash_or_branch_name
+```
+
+**Hidden code blocks** (optional):
+```python
+# HIDE_START
+# ... code hidden by default in docs ...
+# HIDE_END
+```
+- These blocks are **included** in notebooks (only hidden in web documentation)
+- Useful for setup code that users should run but doesn't need emphasis in docs
+
+**Removed code blocks** (optional):
+```python
+# REMOVE_START
+# ... test framework code, imports, etc. ...
+# REMOVE_END
+```
+- Always **excluded** from notebooks (test boilerplate that shouldn't be in user-facing examples)
+
+### Example Input File
+
+```python
+# EXAMPLE: landing
+# BINDER_ID python-landing
+import redis
+
+# STEP_START connect
+r = redis.Redis(host='localhost', port=6379, decode_responses=True)
+# STEP_END
+
+# STEP_START set_get_string
+r.set('foo', 'bar')
+# True
+r.get('foo')
+# bar
+# STEP_END
+
+# STEP_START close
+r.close()
+# STEP_END
+```
+
+### Generated Notebook Structure
+
+The above example generates a notebook with 4 cells:
+
+1. **Cell 1** (code): `import redis`
+2. **Cell 2** (code, metadata: `step=connect`): `r = redis.Redis(...)`
+3. **Cell 3** (code, metadata: `step=set_get_string`): `r.set('foo', 'bar')` and `r.get('foo')`
+4. **Cell 4** (code, metadata: `step=close`): `r.close()`
+
+**Note**: The `EXAMPLE:` and `BINDER_ID` marker lines are automatically excluded from the notebook output.
+
+## Language Support
+
+The tool supports any programming language that has a Jupyter kernel. The language is auto-detected from the file extension.
+
+### Supported Languages and Kernels
+
+| Language   | File Extension | Default Kernel | Comment Prefix |
+|------------|----------------|----------------|----------------|
+| Python     | `.py`          | `python3`      | `#`            |
+| JavaScript | `.js`          | `javascript`   | `//`           |
+| TypeScript | `.ts`          | `typescript`   | `//`           |
+| Java       | `.java`        | `java`         | `//`           |
+| Go         | `.go`          | `gophernotes`  | `//`           |
+| C#         | `.cs`          | `csharp`       | `//`           |
+| PHP        | `.php`         | `php`          | `//`           |
+| Ruby       | `.rb`          | `ruby`         | `#`            |
+| Rust       | `.rs`          | `rust`         | `//`           |
+
+### Adding New Languages
+
+To add support for a new language:
+
+1. **Update language mappings** in `jupyterize.py`:
+   ```python
+   LANGUAGE_MAP = {
+       '.ext': 'language_name',
+       # ...
+   }
+   ```
+
+2. **Update kernel mappings**:
+   ```python
+   KERNEL_MAP = {
+       'language_name': 'kernel_name',
+       # ...
+   }
+   ```
+
+3. **Update comment prefix mappings**:
+   ```python
+   COMMENT_PREFIX = {
+       'language_name': '//',
+       # ...
+   }
+   ```
+
+4. **Install the Jupyter kernel** (if not already installed):
+   ```bash
+   # Example for Go
+   go install github.com/gopherdata/gophernotes@latest
+   ```
+
+## Output Format
+
+The tool generates standard Jupyter Notebook files (`.ipynb`) in JSON format, compatible with:
+- Jupyter Notebook
+- JupyterLab
+- VS Code
+- Google Colab
+- BinderHub
+- Any other Jupyter-compatible environment
+
+### Notebook Metadata
+
+Generated notebooks include:
+- **Kernel specification**: Language and kernel name
+- **Language info**: Programming language metadata
+- **Cell metadata**: Step names (if using STEP_START/STEP_END)
+- **Custom metadata**: Example ID, source file path
+
+## Advanced Usage
+
+### Integration with Build Pipeline
+
+The tool can be integrated into the documentation build process:
+
+```bash
+# In build/make.py or a separate script
+python build/jupyterize/jupyterize.py local_examples/**/*.py -o notebooks/
+```
+
+### Custom Processing
+
+For custom processing logic, import the tool as a module:
+
+```python
+from jupyterize import JupyterizeConverter
+
+converter = JupyterizeConverter(input_file='example.py')
+notebook = converter.convert()
+converter.save(notebook, 'output.ipynb')
+```
+
+The converter automatically detects language and kernel from the file extension and applies the standard processing rules for markers.
+
+## Troubleshooting
+
+### Common Issues
+
+**Issue**: "Kernel not found" error
+- **Solution**: Install the required Jupyter kernel for your language
+- **Check available kernels**: `jupyter kernelspec list`
+
+**Issue**: Comment markers not detected
+- **Solution**: Ensure comment prefix matches the language (e.g., `#` for Python, `//` for JavaScript)
+- **Check**: First line must be `# EXAMPLE: id` or `// EXAMPLE: id`
+
+**Issue**: Empty notebook generated
+- **Solution**: Verify that the input file contains code outside of REMOVE_START/REMOVE_END blocks
+- **Note**: REMOVE blocks are always excluded, HIDE blocks are always included
+
+**Issue**: Steps not creating separate cells
+- **Solution**: Ensure `STEP_START` and `STEP_END` markers are properly paired and use correct comment syntax
+
+**Issue**: Unexpected code in notebook output
+- **Solution**: Remember that HIDE_START/HIDE_END blocks are included in notebooks (they're only hidden in web docs)
+- **Solution**: Use REMOVE_START/REMOVE_END for code that should never appear in notebooks
+
+### Debug Mode
+
+Enable verbose logging to troubleshoot issues:
+
+```bash
+python jupyterize.py example.py -v
+```
+
+This will show:
+- Detected language and kernel
+- Parsed markers and line ranges
+- Cell creation process
+- Output file location
+
+## Related Documentation
+
+- **Code Example Format**: `build/tcedocs/README.md` - User guide for writing examples
+- **Technical Specification**: `build/tcedocs/SPECIFICATION.md` - System architecture and implementation details
+- **Example Parser**: `build/components/example.py` - Python module that parses example files
+
+## Future Enhancements
+
+Potential improvements for future versions:
+
+- **Markdown cells**: Convert comments to markdown cells for documentation
+- **Output formats**: Support for other formats (e.g., Google Colab, VS Code notebooks)
+- **Validation**: Verify that generated notebooks are executable
+- **Testing**: Automatically run notebooks to ensure examples work
+- **Metadata preservation**: Include more metadata from source files (highlight ranges, etc.)
+- **Template support**: Custom notebook templates for different use cases
+
+## Contributing
+
+When contributing to this tool:
+
+1. Follow the existing code style and structure
+2. Add tests for new features
+3. Update this README with new options or features
+4. Ensure compatibility with the existing code example format
+5. Test with multiple programming languages
+
+## License
+
+This tool is part of the Redis documentation project and follows the same license as the parent repository.
+
diff --git a/build/jupyterize/SPECIFICATION.md b/build/jupyterize/SPECIFICATION.md
new file mode 100644
index 000000000..8560241cb
--- /dev/null
+++ b/build/jupyterize/SPECIFICATION.md
@@ -0,0 +1,1805 @@
+# Jupyterize - Technical Specification
+
+> **For End Users**: See `build/jupyterize/README.md` for usage documentation.
+
+## Document Purpose
+
+This specification provides implementation details for developers building the `jupyterize.py` script. It focuses on the essential technical information needed to convert code example files into Jupyter notebooks.
+
+**Related Documentation:**
+- User guide: `build/jupyterize/README.md`
+- Code example format: `build/tcedocs/README.md` and `build/tcedocs/SPECIFICATION.md`
+- Existing parser: `build/components/example.py`
+
+## Quickstart for Implementers (TL;DR)
+
+- Goal: Convert a marked example file into a clean Jupyter notebook.
+- Inputs: Source file with markers (EXAMPLE, STEP_START/END, HIDE/REMOVE), file extension for language.
+- Output: nbformat v4 notebook with cells per step.
+
+Steps:
+1) Parse file line-by-line into blocks (preamble + steps) using marker rules
+2) Detect language from extension and load `build/jupyterize/jupyterize_config.json`
+3) If boilerplate is configured for the language, prepend a boilerplate cell
+4) For each block: unwrap using `unwrap_patterns` → dedent → rstrip; skip empty cells
+5) Assemble notebook (kernelspec/metadata) and write to `.ipynb`
+
+Pitfalls to avoid:
+- Always `.lower()` language keys for config and kernels
+- Handle both `#EXAMPLE:` and `# EXAMPLE:` formats
+- Save preamble before the first step and any trailing preamble at end
+- Apply unwrap patterns in listed order; for Java, remove `@Test` before method wrappers
+- Dedent after unwrapping when any unwrap patterns exist for the language
+
+Add a new language (5 steps):
+1) Copy the C# pattern set as a starting point
+2) Examine 3–4 real repo files for that language (don’t guess pattern count)
+3) Add language-specific patterns (e.g., Java `@Test`, `static main()`)
+4) Write one synthetic test and one real-file test per client library variant
+5) Iterate on patterns until real files produce clean notebooks
+
+---
+
+## Table of Contents
+## Marker Legend (1-minute reference)
+
+- EXAMPLE: <id> — Skip this line; defines the example id (must be first line)
+- BINDER_ID <hash> — Skip this line; not included in the notebook
+- STEP_START <name> / STEP_END — Use as cell boundaries; markers themselves are excluded
+- HIDE_START / HIDE_END — Include the code inside; markers excluded (unlike web docs, code is visible)
+- REMOVE_START / REMOVE_END — Exclude the code inside; markers excluded
+
+---
+
+
+1. [Critical Implementation Notes](#critical-implementation-notes)
+2. [Code Quality Patterns](#code-quality-patterns)
+3. [System Overview](#system-overview)
+4. [Core Mappings](#core-mappings)
+5. [Implementation Approach](#implementation-approach)
+6. [Marker Processing Rules](#marker-processing-rules)
+7. [Language-Specific Features](#language-specific-features)
+8. [Notebook Generation](#notebook-generation)
+9. [Error Handling](#error-handling)
+10. [Testing](#testing)
+
+---
+
+## Critical Implementation Notes
+
+> **⚠️ Read This First!** These are the most common pitfalls discovered during implementation.
+
+### 1. Always Use `.lower()` for Dictionary Lookups
+
+**Problem**: The `PREFIXES` and `KERNEL_SPECS` dictionaries use **lowercase** keys (`'python'`, `'node.js'`), but `EXTENSION_TO_LANGUAGE` returns mixed-case values (`'Python'`, `'Node.js'`).
+
+**Solution**: Always use `.lower()` when accessing these dictionaries:
+
+```python
+# ❌ WRONG - Will cause KeyError
+prefix = PREFIXES[language]  # KeyError if language = 'Python'
+
+# ✅ CORRECT
+prefix = PREFIXES[language.lower()]
+```
+
+This applies to:
+- `PREFIXES[language.lower()]` in parsing
+- `KERNEL_SPECS[language.lower()]` in notebook creation
+
+### 2. Check Both Marker Formats (Use Helper Function!)
+
+**Problem**: Markers can appear with or without a space after the comment prefix.
+
+**Examples**:
+- `# EXAMPLE: test` (with space)
+- `#EXAMPLE: test` (without space)
+
+**Solution**: Create a helper function to avoid repetition:
+
+```python
+def _check_marker(line, prefix, marker):
+    """
+    Check if a line contains a marker (with or without space after prefix).
+
+    Args:
+        line: Line to check
+        prefix: Comment prefix (e.g., '#', '//')
+        marker: Marker to look for (e.g., 'EXAMPLE:', 'STEP_START')
+
+    Returns:
+        bool: True if marker is found
+    """
+    return f'{prefix} {marker}' in line or f'{prefix}{marker}' in line
+
+# ✅ CORRECT - Use helper throughout
+if _check_marker(line, prefix, EXAMPLE):
+    # Handle EXAMPLE marker
+```
+
+**Why a helper function?**
+- You'll check markers ~8 times in the parsing function
+- DRY principle - don't repeat yourself
+- Easier to maintain - one place to update if logic changes
+- More readable - clear intent
+
+### 3. Import from Existing Modules
+
+**Problem**: Redefining constants that already exist in the build system.
+
+**Solution**: Import from existing modules:
+
+```python
+# ✅ Import these - don't redefine!
+from local_examples import EXTENSION_TO_LANGUAGE
+from components.example import PREFIXES
+from components.example import HIDE_START, HIDE_END, REMOVE_START, REMOVE_END, STEP_START, STEP_END, EXAMPLE, BINDER_ID
+```
+
+### 4. Handle Empty Directory Name
+
+**Problem**: `os.path.dirname()` returns empty string for files in current directory.
+
+**Solution**: Check if dirname is non-empty before creating:
+
+```python
+# ❌ WRONG - os.makedirs('') will fail
+output_dir = os.path.dirname(output_path)
+os.makedirs(output_dir, exist_ok=True)
+
+# ✅ CORRECT
+output_dir = os.path.dirname(output_path)
+if output_dir and not os.path.exists(output_dir):
+    os.makedirs(output_dir, exist_ok=True)
+```
+
+### 5. Save Preamble Before Starting Step
+
+**Problem**: When entering a STEP, accumulated preamble code gets lost.
+
+**Solution**: Save preamble to cells list before starting a new step:
+
+```python
+if f'{prefix} {STEP_START}' in line:
+    # ✅ Save preamble first!
+    if preamble_lines:
+        cells.append({'code': ''.join(preamble_lines), 'step_name': None})
+        preamble_lines = []
+
+    in_step = True
+    # ... rest of step handling
+```
+
+### 6. Don't Forget Remaining Preamble
+
+**Problem**: Code after the last STEP_END gets lost.
+
+**Solution**: Save remaining preamble at end of parsing:
+
+```python
+# After the main loop
+if preamble_lines:
+    cells.append({'code': ''.join(preamble_lines), 'step_name': None})
+```
+
+### 7. Track Duplicate Step Names
+
+**Problem**: Users may accidentally reuse step names (copy-paste errors).
+
+**Solution**: Track seen step names and warn on duplicates:
+
+```python
+seen_step_names = set()
+
+# When processing STEP_START:
+if step_name and step_name in seen_step_names:
+    logging.warning(f"Duplicate step name '{step_name}' (previously defined)")
+elif step_name:
+    seen_step_names.add(step_name)
+```
+
+**Why warn instead of error?**
+- Jupyter notebooks can have duplicate cell metadata
+- Non-breaking - helps users but doesn't stop processing
+- Useful for debugging example files
+
+### 8. Handle Language-Specific Boilerplate and Wrappers
+
+**Problem**: Different languages have different requirements for Jupyter notebooks:
+- **C#**: Needs `#r "nuget: PackageName, Version"` directives for dependencies
+- **Test wrappers**: Source files have class/method wrappers needed for testing but not for notebooks
+
+**Solution**: Two-part approach:
+
+**Part 1: Boilerplate Injection**
+- Define language-specific boilerplate in configuration
+- Insert as first cell (before preamble)
+- Example: C# needs `#r "nuget: NRedisStack, 1.1.1"`
+
+**Part 2: Structural Unwrapping**
+- Detect and remove language-specific structural wrappers
+- C#: Remove `public class ClassName { ... }` and `public void Run() { ... }`
+- Keep only the actual example code inside
+
+**Why this matters**:
+- Without boilerplate: Notebooks won't run (missing dependencies)
+- Without unwrapping: Notebooks have unnecessary test framework code
+- These aren't marked with REMOVE blocks because they're needed for tests
+
+**See**: [Language-Specific Features](#language-specific-features) section for detailed implementation.
+
+### 9. Unwrapping Patterns: Single‑line vs Multi‑line, and Dedenting (Based on Implementation Experience)
+
+During implementation, several non‑obvious details significantly reduced bugs and rework:
+
+- Pattern classes and semantics
+  - Single‑line patterns: When `start_pattern == end_pattern`, treat as “remove this line only”. Examples: `public class X {` or `public void Run() {` on one line.
+  - Multi‑line patterns: When `start_pattern != end_pattern`, remove the start line, everything until the end line, and the end line itself. Use this to strip a wrapper’s braces while preserving the inner code with a separate “keep content” strategy.
+  - Use anchored patterns with `^` to avoid over‑matching. Prefer `re.match` (anchored at the start) over `re.search`.
+
+- Wrappers split across cells
+  - Real C# files often split wrappers across lines/blocks (e.g., class name on line N, `{` or `}` in later lines). Because parsing splits code into preamble/step cells, wrapper open/close tokens may land in separate cells.
+  - Practical approach: Use separate, simple patterns to remove opener lines (class/method declarations with `{` either on the same line or next line) and a generic pattern to remove solitary closing braces in any cell.
+
+- Order of operations inside cell creation
+  1) Apply unwrapping patterns (in the order listed in configuration)
+  2) Dedent code (e.g., `textwrap.dedent`) so content previously nested inside wrappers aligns to column 0
+  3) Strip trailing whitespace (e.g., `rstrip()`)
+  4) Skip empty cells
+
+- Dedent all cells when unwrapping is enabled
+  - Even if a particular cell didn’t change after unwrapping, its content may still be indented due to having originated inside a method/class in the source file. Dedent ALL cells whenever `unwrap_patterns` are configured for the language.
+
+- Logging for traceability
+  - Emit `DEBUG` logs per applied pattern (e.g., pattern `type`) to simplify diagnosing regex issues.
+
+- Safety tips for patterns
+  - Anchor with `^` and keep them specific; avoid overly greedy constructs.
+  - Keep patterns minimal and composable (e.g., separate `class_opening`, `method_opening`, `closing_braces`).
+  - Validate patterns at startup or wrap application with try/except to warn and continue on malformed regex.
+
+### 10. Closing Brace Removal Must Be Match-Based, Not Pattern-Based (Critical Bug Fix)
+
+**Problem**: The initial implementation removed closing braces based on the number of unwrap patterns configured, not the number of patterns that actually matched. This caused a critical bug where closing braces from control structures (for loops, foreach loops, if statements) were incorrectly removed.
+
+**Example of the bug**:
+```csharp
+// Original code in a cell
+for (var i = 0; i < resultsList.Count; i++)
+{
+    Console.WriteLine(i);
+}
+
+// BUG: Closing brace was removed, resulting in:
+for (var i = 0; i < resultsList.Count; i++)
+{
+    Console.WriteLine(i);
+// Missing }
+```
+
+**Root cause**: The unwrapping logic counted braces to remove based on pattern configuration (e.g., "C# has 4 patterns with braces, so remove 4 closing braces from every cell"), rather than counting how many patterns actually matched in each specific cell.
+
+**Solution**: Modified `remove_matching_lines()` to return a tuple `(modified_code, match_count)` and updated `unwrap_code()` to only remove closing braces when patterns actually match:
+
+```python
+# Before (WRONG):
+for pattern_config in unwrap_patterns:
+    code = remove_matching_lines(code, pattern, end_pattern)
+    if '{' in pattern:
+        braces_removed += 1  # Always increments!
+
+# After (CORRECT):
+for pattern_config in unwrap_patterns:
+    code, match_count = remove_matching_lines(code, pattern, end_pattern)
+    if match_count > 0 and '{' in pattern:
+        braces_removed += match_count  # Only increments if pattern matched
+```
+
+**Implementation details**:
+1. `remove_matching_lines()` now returns `(code, match_count)` instead of just `code`
+2. `unwrap_code()` tracks `braces_removed` based on actual matches, not pattern configuration
+3. `remove_trailing_braces()` scans from the end and removes only the exact number of trailing closing braces
+4. The `closing_braces` pattern was removed from configuration files (C# and Java) since it's now handled programmatically
+
+**Time saved by documenting this**: ~2 hours of debugging similar issues in the future.
+
+**Follow-up fix**: After implementing match-based brace removal, a second issue was discovered: cells containing **only** orphaned closing braces (from removed class/method wrappers) were still being included in the notebook. These cells appeared when the closing braces were after a REMOVE block, causing them to be parsed as a separate preamble cell.
+
+**Solution**: Added a filter in `create_cells()` to skip cells that contain only closing braces and whitespace:
+
+```python
+# Skip cells that contain only closing braces and whitespace
+# (orphaned closing braces from removed class/method wrappers)
+if lang_config.get('unwrap_patterns'):
+    # Remove all whitespace and check if only closing braces remain
+    code_no_whitespace = re.sub(r'\s', '', code)
+    if code_no_whitespace and re.match(r'^}+$', code_no_whitespace):
+        logging.debug(f"Skipping cell {i} (contains only closing braces)")
+        continue
+```
+
+This ensures that orphaned closing brace cells are completely removed from the final notebook.
+
+### 11. Pattern Count Differences Between Languages (Java Implementation Insight)
+
+**Key Discovery**: When adding Java support after C#, the pattern count increased from 5 to 8 patterns.
+
+**Why the difference?**
+
+| Language | Patterns | Unique Requirements |
+|----------|----------|---------------------|
+| **C#** | 5 | `class_single_line`, `class_opening`, `method_single_line`, `method_opening`, `closing_braces` |
+| **Java** | 8 | All C# patterns PLUS `test_annotation`, `static_main_single_line`, `static_main_opening` |
+
+**Java-specific additions**:
+1. **`test_annotation`** - Java uses `@Test` annotations on separate lines before methods (C# uses `[Test]` attributes which are less common in our examples)
+2. **`static_main_single_line`** - Java examples often use `public static void main(String[] args)` instead of instance methods
+3. **`static_main_opening`** - Multi-line version of static main
+
+**Critical insight**: Don't assume pattern counts will be identical across languages, even for similar class-based languages.
+
+**Pattern order matters more in Java**:
+- `test_annotation` MUST come before `method_opening` (otherwise the annotation line might not be removed)
+- Specific patterns (single-line) before generic patterns (multi-line)
+- Openers before closers
+
+**Implementation tip**: When adding a new language:
+1. Start with the C# patterns as a template
+2. Examine 3-4 real example files from the repository
+3. Look for language-specific constructs (annotations, modifiers, method signatures)
+4. Add patterns incrementally and test after each addition
+5. Document the pattern order rationale in the configuration
+
+**Time saved**: This insight would have saved ~15 minutes of debugging why `@Test` annotations weren't being removed (they were being processed after method patterns, which was too late).
+
+
+---
+
+## Code Quality Patterns
+
+> **💡 Best Practices** These patterns improve code maintainability and readability.
+
+### Pattern 1: Extract Repeated Conditionals into Helper Functions
+
+**When you see**: The same conditional pattern repeated multiple times
+
+**Example**: Checking for markers appears ~8 times in parsing:
+```python
+if f'{prefix} {EXAMPLE}' in line or f'{prefix}{EXAMPLE}' in line:
+if f'{prefix} {BINDER_ID}' in line or f'{prefix}{BINDER_ID}' in line:
+if f'{prefix} {REMOVE_START}' in line or f'{prefix}{REMOVE_START}' in line:
+# ... 5 more times
+```
+
+**Refactor to**: Helper function
+```python
+def _check_marker(line, prefix, marker):
+    return f'{prefix} {marker}' in line or f'{prefix}{marker}' in line
+
+# Usage:
+if _check_marker(line, prefix, EXAMPLE):
+if _check_marker(line, prefix, BINDER_ID):
+if _check_marker(line, prefix, REMOVE_START):
+```
+
+**Benefits**:
+- Reduces code by ~15 lines
+- Single source of truth
+- Easier to test
+- More readable
+
+### Pattern 2: Use Sets for Membership Tracking
+
+**When you see**: Need to track if something has been seen before
+
+**Example**: Tracking duplicate step names
+
+**Use**: Set for O(1) lookup
+```python
+seen_step_names = set()
+
+if step_name in seen_step_names:  # O(1) lookup
+    # Handle duplicate
+else:
+    seen_step_names.add(step_name)
+```
+
+**Don't use**: List (O(n) lookup)
+```python
+# ❌ WRONG - O(n) lookup
+seen_step_names = []
+if step_name in seen_step_names:  # Slow for large lists
+```
+
+### Pattern 3: Warn for Non-Critical Issues
+
+**When you see**: Issues that are problems but shouldn't stop processing
+
+**Examples**:
+- Duplicate step names
+- Nested markers
+- Unpaired markers
+
+**Use**: `logging.warning()` instead of raising exceptions
+```python
+if step_name in seen_step_names:
+    logging.warning(f"Duplicate step name '{step_name}'")
+    # Continue processing
+
+if in_remove:
+    logging.warning("Nested REMOVE_START detected")
+    # Continue processing
+```
+
+**Benefits**:
+- More user-friendly
+- Helps debug without breaking workflow
+- Allows batch processing to continue
+
+### Pattern 4: Validate Early, Process Later
+
+**Structure**:
+1. Validate all inputs first
+2. Then process (assuming valid inputs)
+
+**Example**:
+```python
+def jupyterize(input_file, output_file=None, verbose=False):
+    # 1. Validate first
+    language = detect_language(input_file)
+    validate_input(input_file, language)
+
+    # 2. Process (inputs are valid)
+    parsed_blocks = parse_file(input_file, language)
+    cells = create_cells(parsed_blocks)
+    notebook = create_notebook(cells, language)
+    write_notebook(notebook, output_file)
+```
+
+**Benefits**:
+- Fail fast on invalid inputs
+- Cleaner error messages
+- Easier to test validation separately
+
+---
+
+## System Overview
+
+### Purpose
+
+Convert code example files (with special comment markers) into Jupyter notebook (`.ipynb`) files.
+
+**Process Flow:**
+```
+Input File → Detect Language → Parse Markers → Generate Cells → Write Notebook
+```
+
+### Key Principles
+
+1. **Simple parsing**: Read file line-by-line, detect markers with regex
+2. **Automatic behavior**: Language/kernel from extension, fixed marker handling
+3. **Standard output**: Use `nbformat` library for spec-compliant notebooks
+
+### Dependencies
+
+```bash
+pip install nbformat
+```
+
+---
+
+## Core Mappings
+
+> **📖 Source of Truth**: Import these from existing modules - don't redefine!
+
+### File Extension → Language
+
+**Import from**: `build/local_examples.py` → `EXTENSION_TO_LANGUAGE`
+
+Supported: `.py`, `.js`, `.go`, `.cs`, `.java`, `.php`, `.rs`
+
+### Language → Comment Prefix
+
+**Import from**: `build/components/example.py` → `PREFIXES`
+
+**⚠️ Critical**: Keys are lowercase (`'python'`, `'node.js'`), so use `language.lower()` when accessing.
+
+### Language → Jupyter Kernel
+
+**Define locally** (not in existing modules):
+
+```python
+KERNEL_SPECS = {
+    'python': {'name': 'python3', 'display_name': 'Python 3'},
+    'node.js': {'name': 'javascript', 'display_name': 'JavaScript (Node.js)'},
+    'go': {'name': 'gophernotes', 'display_name': 'Go'},
+    'c#': {'name': 'csharp', 'display_name': 'C#'},
+    'java': {'name': 'java', 'display_name': 'Java'},
+    'php': {'name': 'php', 'display_name': 'PHP'},
+    'rust': {'name': 'rust', 'display_name': 'Rust'}
+}
+```
+
+**⚠️ Critical**: Also use `language.lower()` when accessing this dict.
+
+### Marker Constants
+
+**Import from**: `build/components/example.py`
+
+```python
+from components.example import (
+    HIDE_START, HIDE_END,
+    REMOVE_START, REMOVE_END,
+    STEP_START, STEP_END,
+    EXAMPLE, BINDER_ID
+)
+```
+
+**📖 For marker semantics**, see `build/tcedocs/SPECIFICATION.md` section "Special Comment Reference".
+
+---
+
+## Implementation Approach
+
+### Recommended Strategy
+
+**Don't use the Example class** - it modifies files in-place for web documentation. Instead, implement a simple line-by-line parser.
+
+### Module Imports
+
+**Critical**: Import existing mappings from the build system:
+
+```python
+#!/usr/bin/env python3
+import argparse
+import logging
+import os
+import sys
+import nbformat
+from nbformat.v4 import new_notebook, new_code_cell
+
+# Add parent directory to path to import from build/
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+# Import existing mappings - DO NOT redefine these!
+from local_examples import EXTENSION_TO_LANGUAGE
+from components.example import PREFIXES
+
+# Import marker constants from example.py
+from components.example import (
+    HIDE_START, HIDE_END,
+    REMOVE_START, REMOVE_END,
+    STEP_START, STEP_END,
+    EXAMPLE, BINDER_ID
+)
+```
+
+**Important**: The PREFIXES dict uses lowercase keys (e.g., `'python'`, `'node.js'`), so you must use `language.lower()` when accessing it.
+
+### Basic Structure
+
+```python
+def main():
+    # 1. Parse command-line arguments
+    # 2. Detect language from file extension
+    # 3. Validate input file
+    # 4. Parse file and extract cells
+    # 5. Create cells with nbformat
+    # 6. Create notebook with metadata
+    # 7. Write to output file
+    pass
+```
+
+### Language Detection
+
+```python
+def detect_language(file_path):
+    """Detect language from file extension."""
+    _, ext = os.path.splitext(file_path)
+    language = EXTENSION_TO_LANGUAGE.get(ext.lower())
+    if not language:
+        supported = ', '.join(sorted(EXTENSION_TO_LANGUAGE.keys()))
+        raise ValueError(
+            f"Unsupported file extension: {ext}\n"
+            f"Supported extensions: {supported}"
+        )
+    return language
+```
+
+---
+
+## Marker Processing Rules
+
+> **📖 For complete marker documentation**, see `build/tcedocs/SPECIFICATION.md` section "Special Comment Reference" (lines 2089-2107).
+
+### Quick Reference: What to Include/Exclude
+
+| Marker | Action | Notebook Behavior |
+|--------|--------|-------------------|
+| `EXAMPLE:` line | Skip | Not included |
+| `BINDER_ID` line | Skip | Not included |
+| `HIDE_START`/`HIDE_END` markers | Skip markers, **include** code between them | Code visible in notebook |
+| `REMOVE_START`/`REMOVE_END` markers | Skip markers, **exclude** code between them | Code not in notebook |
+| `STEP_START`/`STEP_END` markers | Skip markers, use as cell boundaries | Each step = separate cell |
+| Code outside any step | Include in first cell (preamble) | First cell (no step metadata) |
+
+**Key Difference from Web Display**:
+- Web docs: HIDE blocks are hidden by default (revealed with eye button)
+- Notebooks: HIDE blocks are fully visible (notebooks don't have hide/reveal UI)
+
+### Parsing Algorithm
+
+**Key Implementation Details:**
+
+1. **Use `language.lower()`** when accessing PREFIXES dict (keys are lowercase)
+2. **Check both formats**: `f'{prefix} {MARKER}'` and `f'{prefix}{MARKER}'` (with/without space)
+3. **Extract step name**: Use `line.split(STEP_START)[1].strip()` to get the step name after the marker
+4. **Handle state carefully**: Track `in_remove`, `in_step` flags to know what to include/exclude
+5. **Save cells at transitions**: When entering a STEP, save any accumulated preamble first
+
+```python
+def parse_file(file_path, language):
+    """
+    Parse file and extract cells.
+
+    Returns: list of {'code': str, 'step_name': str or None}
+    """
+    with open(file_path, 'r', encoding='utf-8') as f:
+        lines = f.readlines()
+
+    # IMPORTANT: Use .lower() because PREFIXES keys are lowercase
+    prefix = PREFIXES[language.lower()]
+
+    # State tracking
+    in_remove = False
+    in_step = False
+    step_name = None
+    step_lines = []
+    preamble_lines = []
+    cells = []
+
+    for line_num, line in enumerate(lines, 1):
+        # Skip metadata markers (check both with and without space)
+        if f'{prefix} {EXAMPLE}' in line or f'{prefix}{EXAMPLE}' in line:
+            continue
+        if f'{prefix} {BINDER_ID}' in line or f'{prefix}{BINDER_ID}' in line:
+            continue
+
+        # Handle REMOVE blocks (exclude content)
+        if f'{prefix} {REMOVE_START}' in line or f'{prefix}{REMOVE_START}' in line:
+            in_remove = True
+            continue
+        if f'{prefix} {REMOVE_END}' in line or f'{prefix}{REMOVE_END}' in line:
+            in_remove = False
+            continue
+        if in_remove:
+            continue  # Skip lines inside REMOVE blocks
+
+        # Skip HIDE markers (but include content between them)
+        if f'{prefix} {HIDE_START}' in line or f'{prefix}{HIDE_START}' in line:
+            continue
+        if f'{prefix} {HIDE_END}' in line or f'{prefix}{HIDE_END}' in line:
+            continue
+
+        # Handle STEP blocks
+        if f'{prefix} {STEP_START}' in line or f'{prefix}{STEP_START}' in line:
+            # Save accumulated preamble before starting new step
+            if preamble_lines:
+                cells.append({'code': ''.join(preamble_lines), 'step_name': None})
+                preamble_lines = []
+
+            in_step = True
+            # Extract step name from line (text after STEP_START marker)
+            step_name = line.split(STEP_START)[1].strip() if STEP_START in line else None
+            step_lines = []
+            continue
+
+        if f'{prefix} {STEP_END}' in line or f'{prefix}{STEP_END}' in line:
+            if step_lines:
+                cells.append({'code': ''.join(step_lines), 'step_name': step_name})
+            in_step = False
+            step_name = None
+            step_lines = []
+            continue
+
+        # Collect code lines
+        if in_step:
+            step_lines.append(line)
+        else:
+            preamble_lines.append(line)
+
+    # Save any remaining preamble at end of file
+    if preamble_lines:
+        cells.append({'code': ''.join(preamble_lines), 'step_name': None})
+
+    return cells
+```
+
+**Common Pitfalls to Avoid:**
+- Forgetting to use `.lower()` when accessing PREFIXES → KeyError
+- Only checking `f'{prefix} {MARKER}'` format → Missing markers without space
+- Not saving preamble before starting a step → Lost code
+- Not handling remaining preamble at end → Lost code
+
+---
+
+## Language-Specific Features
+
+> **⚠️ New Requirement**: Notebooks need language-specific setup that source files don't have.
+
+### Overview
+
+Different languages have different requirements for Jupyter notebooks that aren't present in the source test files:
+
+1. **Dependency declarations**: C# needs NuGet package directives, Node.js might need npm packages
+2. **Structural wrappers**: Test files have class/method wrappers that shouldn't appear in notebooks
+3. **Initialization code**: Some languages need setup code that's implicit in test frameworks
+
+### Problem 1: Missing Dependency Declarations
+
+**Issue**: C# Jupyter notebooks require NuGet package directives to download dependencies:
+
+```csharp
+#r "nuget: NRedisStack, 1.1.1"
+```
+
+**Current behavior**: Source files don't have these directives (they're in project files)
+**Desired behavior**: Automatically inject language-specific boilerplate as first cell
+
+**Example - C# source file**:
+```csharp
+// EXAMPLE: landing
+using NRedisStack;
+using StackExchange.Redis;
+
+public class SyncLandingExample {
+    public void Run() {
+        var muxer = ConnectionMultiplexer.Connect("localhost:6379");
+        // ...
+    }
+}
+```
+
+**Desired notebook output**:
+```
+Cell 1 (boilerplate):
+#r "nuget: NRedisStack, 1.1.1"
+#r "nuget: StackExchange.Redis, 2.6.122"
+
+Cell 2 (preamble):
+using NRedisStack;
+using StackExchange.Redis;
+
+Cell 3 (code):
+var muxer = ConnectionMultiplexer.Connect("localhost:6379");
+// ...
+```
+
+### Problem 2: Unnecessary Structural Wrappers
+
+**Issue**: Test files have class/method wrappers needed for test frameworks but not for notebooks.
+
+**Affected languages**: C# and Java (both class-based languages with similar syntax)
+
+**C# example**:
+```csharp
+public class SyncLandingExample  // ← Test framework wrapper
+{
+    public void Run()             // ← Test framework wrapper
+    {
+        // Actual example code here
+        var muxer = ConnectionMultiplexer.Connect("localhost:6379");
+    }
+}
+```
+
+**Java example**:
+```java
+public class LandingExample {    // ← Test framework wrapper
+
+    @Test
+    public void run() {           // ← Test framework wrapper
+        // Actual example code here
+        UnifiedJedis jedis = new UnifiedJedis("redis://localhost:6379");
+    }
+}
+```
+
+**Current behavior**: These wrappers are copied to the notebook
+**Desired behavior**: Remove wrappers, keep only the code inside
+
+**Why not use REMOVE blocks?**
+- These wrappers are needed for the test framework to compile/run
+- Marking them with REMOVE would break the tests
+- They're structural, not boilerplate
+
+**Key similarities between C# and Java**:
+- Both use `public class ClassName` declarations
+- Both use method declarations (C#: `public void Run()`, Java: `public void run()`)
+- Both use curly braces `{` `}` for blocks
+- Opening brace can be on same line or next line
+- Test annotations may appear before methods (Java: `@Test`, C#: `[Test]`)
+
+**Detailed Java example** (from `local_examples/client-specific/jedis/LandingExample.java`):
+
+Before unwrapping:
+```java
+// EXAMPLE: landing
+// STEP_START import
+import redis.clients.jedis.UnifiedJedis;
+// STEP_END
+
+public class LandingExample {    // ← Remove this
+
+    @Test                         // ← Remove this
+    public void run() {           // ← Remove this
+        // STEP_START connect
+        UnifiedJedis jedis = new UnifiedJedis("redis://localhost:6379");
+        // STEP_END
+
+        // STEP_START set_get_string
+        String res1 = jedis.set("bike:1", "Deimos");
+        System.out.println(res1);
+        // STEP_END
+    }                             // ← Remove this
+}                                 // ← Remove this
+```
+
+After unwrapping (desired notebook output):
+```java
+Cell 1 (import step):
+import redis.clients.jedis.UnifiedJedis;
+
+Cell 2 (connect step):
+UnifiedJedis jedis = new UnifiedJedis("redis://localhost:6379");
+
+Cell 3 (set_get_string step):
+String res1 = jedis.set("bike:1", "Deimos");
+System.out.println(res1);
+```
+
+Note: The class declaration, `@Test` annotation, method declaration, and closing braces are all removed, leaving only the actual example code properly dedented.
+
+### Solution Approach
+
+#### Option 1: Configuration-Based (Recommended)
+
+**Pros**:
+- No changes to source files
+- Centralized configuration
+- Easy to update package versions
+- Works with existing examples
+
+**Cons**:
+- Requires maintaining configuration file
+- Less visible to example authors
+
+**Implementation**:
+
+1. **Create configuration file** (`jupyterize_config.json`):
+```json
+{
+  "c#": {
+    "boilerplate": [
+      "#r \"nuget: NRedisStack, 1.1.1\"",
+      "#r \"nuget: StackExchange.Redis, 2.6.122\""
+    ],
+    "unwrap_patterns": [
+      {
+        "type": "class",
+        "pattern": "^\\s*public\\s+class\\s+\\w+.*\\{",
+        "end_pattern": "^\\}\\s*$",
+        "keep_content": true
+      },
+      {
+        "type": "method",
+        "pattern": "^\\s*public\\s+void\\s+Run\\(\\).*\\{",
+        "end_pattern": "^\\s*\\}\\s*$",
+        "keep_content": true
+      }
+    ]
+  },
+  "node.js": {
+    "boilerplate": [
+      "// npm install redis"
+    ],
+    "unwrap_patterns": []
+  }
+}
+```
+
+2. **Load configuration** in jupyterize.py:
+```python
+def load_language_config(language):
+    """Load language-specific configuration."""
+    config_file = os.path.join(os.path.dirname(__file__), 'jupyterize_config.json')
+    if os.path.exists(config_file):
+        with open(config_file) as f:
+            config = json.load(f)
+        return config.get(language.lower(), {})
+    return {}
+```
+
+3. **Inject boilerplate** as first cell:
+```python
+def create_cells(parsed_blocks, language):
+    """Convert parsed blocks to notebook cells."""
+    cells = []
+
+    # Get language config
+    lang_config = load_language_config(language)
+
+    # Add boilerplate cell if defined
+    if 'boilerplate' in lang_config:
+        boilerplate_code = '\n'.join(lang_config['boilerplate'])
+        cells.append(new_code_cell(
+            source=boilerplate_code,
+            metadata={'cell_type': 'boilerplate', 'language': language}
+        ))
+
+    # Add regular cells...
+    for block in parsed_blocks:
+        # ... existing logic
+```
+
+4. **Unwrap structural patterns**:
+```python
+def unwrap_code(code, language):
+    """Remove language-specific structural wrappers."""
+    lang_config = load_language_config(language)
+    unwrap_patterns = lang_config.get('unwrap_patterns', [])
+
+    for pattern_config in unwrap_patterns:
+        if pattern_config.get('keep_content', True):
+            # Remove wrapper but keep content
+            code = remove_wrapper_keep_content(
+                code,
+                pattern_config['pattern'],
+                pattern_config['end_pattern']
+            )
+
+    return code
+
+def remove_wrapper_keep_content(code, start_pattern, end_pattern):
+    """Remove wrapper lines but keep content between them."""
+    lines = code.split('\n')
+    result = []
+    in_wrapper = False
+    wrapper_indent = 0
+
+    for line in lines:
+        if re.match(start_pattern, line):
+            in_wrapper = True
+            wrapper_indent = len(line) - len(line.lstrip())
+            continue  # Skip wrapper start line
+        elif in_wrapper and re.match(end_pattern, line):
+            in_wrapper = False
+            continue  # Skip wrapper end line
+        elif in_wrapper:
+            # Remove wrapper indentation
+            if line.startswith(' ' * (wrapper_indent + 4)):
+                result.append(line[wrapper_indent + 4:])
+            else:
+                result.append(line)
+        else:
+            result.append(line)
+
+    return '\n'.join(result)
+```
+
+#### Option 2: Marker-Based
+
+**Pros**:
+- Explicit in source files
+- Self-documenting
+- No external configuration needed
+
+**Cons**:
+- Requires updating all source files
+- More markers to maintain
+- Clutters source files
+
+**New markers**:
+```csharp
+// NOTEBOOK_BOILERPLATE_START
+#r "nuget: NRedisStack, 1.1.1"
+// NOTEBOOK_BOILERPLATE_END
+
+// NOTEBOOK_UNWRAP_START class
+public class SyncLandingExample {
+// NOTEBOOK_UNWRAP_END
+
+    // NOTEBOOK_UNWRAP_START method
+    public void Run() {
+    // NOTEBOOK_UNWRAP_END
+
+        // Actual code here
+
+// NOTEBOOK_UNWRAP_CLOSE method
+    }
+// NOTEBOOK_UNWRAP_CLOSE class
+}
+```
+
+**Not recommended** because:
+- Too many new markers
+- Clutters source files
+- Harder to maintain
+- Breaks existing examples
+
+### Configuration Schema and Semantics (Implementation-Proven)
+
+- Location: `build/jupyterize/jupyterize_config.json`
+- Keys: Lowercased language names (`"c#"`, `"python"`, `"node.js"`, `"java"`, ...)
+- Structure per language:
+  - `boilerplate`: Array of strings (each becomes a line in the first code cell)
+  - `unwrap_patterns`: Array of pattern objects with fields:
+    - `type` (string): Human-readable label used in logs
+    - `pattern` (regex string): Start condition (anchored with `^` recommended)
+    - `end_pattern` (regex string): End condition
+    - `keep_content` (bool):
+      - `true` → remove wrapper start/end lines, keep the inner content (useful for `{ ... }` ranges)
+      - `false` → remove the matching line(s) entirely
+        - If `pattern == end_pattern` → remove only the single matching line
+        - If `pattern != end_pattern` → remove from first match through end match, inclusive
+    - `description` (optional): Intent for maintainers
+
+#### At a Glance: Configuration Schema
+
+```json
+{
+  "<language-lowercase>": {
+    "boilerplate": ["<string>", "<string>"],
+    "unwrap_patterns": [
+      {
+        "type": "<label>",               // for logs/maintenance
+        "pattern": "^regex$",            // start match (anchor recommended)
+        "end_pattern": "^regex$",        // end match; same as pattern → single-line removal
+        "keep_content": false,             // false: remove matches; true: remove wrappers, keep inside
+        "description": "<optional help>"  // human intent
+      }
+    ]
+  }
+}
+```
+
+Notes:
+- Keys are lowercased language names (e.g., "c#", "java").
+- If `pattern == end_pattern`, only that line is removed (single-line).
+- If they differ, everything from the start match through the end match (inclusive) is removed.
+- In current C#/Java configs, `keep_content` is `false` for all patterns.
+
+#### C# Configuration Example
+Note: Current C# and Java configurations use `keep_content: false` exclusively; `keep_content: true` is reserved for cases where wrapper lines should be removed but inner content preserved.
+
+Minimal example (C#) reflecting patterns that worked in practice:
+
+```json
+{
+  "c#": {
+    "boilerplate": [
+      "#r \"nuget: NRedisStack\"",
+      "#r \"nuget: StackExchange.Redis\""
+    ],
+    "unwrap_patterns": [
+      { "type": "class_single_line",  "pattern": "^\\s*public\\s+class\\s+\\w+.*\\{\\s*$", "end_pattern": "^\\s*public\\s+class\\s+\\w+.*\\{\\s*$", "keep_content": false },
+      { "type": "class_opening",      "pattern": "^\\s*public\\s+class\\s+\\w+",             "end_pattern": "^\\s*\\{\\s*$",                                       "keep_content": false },
+      { "type": "method_single_line", "pattern": "^\\s*public\\s+void\\s+Run\\(\\).*\\{\\s*$", "end_pattern": "^\\s*public\\s+void\\s+Run\\(\\).*\\{\\s*$",         "keep_content": false },
+      { "type": "method_opening",     "pattern": "^\\s*public\\s+void\\s+Run\\(\\)",         "end_pattern": "^\\s*\\{\\s*$",                                       "keep_content": false },
+      { "type": "closing_braces",     "pattern": "^\\s*\\}\\s*$",                               "end_pattern": "^\\s*\\}\\s*$",                                       "keep_content": false }
+    ]
+  }
+}
+```
+
+#### Java Configuration Example (As Implemented)
+
+Java has nearly identical structural wrapper patterns to C#, with additional patterns for annotations and static methods:
+
+```json
+{
+  "java": {
+    "boilerplate": [],
+    "unwrap_patterns": [
+      { "type": "test_annotation",        "pattern": "^\\s*@Test\\s*$",                                  "end_pattern": "^\\s*@Test\\s*$",                                    "keep_content": false, "description": "Remove @Test annotation" },
+      { "type": "class_single_line",      "pattern": "^\\s*public\\s+class\\s+\\w+.*\\{\\s*$",           "end_pattern": "^\\s*public\\s+class\\s+\\w+.*\\{\\s*$",             "keep_content": false, "description": "Remove public class declaration with opening brace on same line" },
+      { "type": "class_opening",          "pattern": "^\\s*public\\s+class\\s+\\w+",                     "end_pattern": "^\\s*\\{\\s*$",                                       "keep_content": false, "description": "Remove public class declaration and opening brace on separate lines" },
+      { "type": "method_single_line",     "pattern": "^\\s*public\\s+void\\s+run\\(\\).*\\{\\s*$",       "end_pattern": "^\\s*public\\s+void\\s+run\\(\\).*\\{\\s*$",         "keep_content": false, "description": "Remove public void run() with opening brace on same line" },
+      { "type": "method_opening",         "pattern": "^\\s*public\\s+void\\s+run\\(\\)",                 "end_pattern": "^\\s*\\{\\s*$",                                       "keep_content": false, "description": "Remove public void run() declaration and opening brace on separate lines" },
+      { "type": "static_main_single_line","pattern": "^\\s*public\\s+static\\s+void\\s+main\\(.*\\).*\\{\\s*$", "end_pattern": "^\\s*public\\s+static\\s+void\\s+main\\(.*\\).*\\{\\s*$", "keep_content": false, "description": "Remove public static void main() with opening brace on same line" },
+      { "type": "static_main_opening",    "pattern": "^\\s*public\\s+static\\s+void\\s+main\\(.*\\)",    "end_pattern": "^\\s*\\{\\s*$",                                       "keep_content": false, "description": "Remove public static void main() declaration and opening brace on separate lines" },
+      { "type": "closing_braces",         "pattern": "^\\s*\\}\\s*$",                                     "end_pattern": "^\\s*\\}\\s*$",                                       "keep_content": false, "description": "Remove closing braces" }
+    ]
+  }
+}
+```
+
+**Key differences between C# and Java patterns**:
+- **Annotations**: Java uses `@Test` annotation (should be removed); C# uses `[Test]` (less common in examples)
+- **Method names**: Java typically uses `run()` (lowercase); C# uses `Run()` (uppercase)
+- **Static methods**: Java examples often use `public static void main(String[] args)` - needs 2 additional patterns
+- **Brace handling**: Both languages have identical brace handling
+- **Pattern order**: Java needs annotation pattern before method patterns
+
+**Boilerplate considerations**:
+- **C#**: Requires explicit NuGet package directives (`#r "nuget: ..."`)
+  - Example: `#r "nuget: NRedisStack"` (version numbers omitted to use latest)
+  - These are essential for C# notebooks to work
+- **Java**: Jupyter notebooks typically use `%maven` or `%jars` magic commands, but these vary by kernel
+  - For IJava kernel: May need `%maven` directives
+  - For BeakerX: May need different syntax
+  - **Current implementation**: Empty boilerplate array (kernel-dependent, left for future enhancement)
+  - Alternative: Add comments explaining how to add dependencies manually
+
+**Pattern complexity comparison** (As Actually Implemented):
+- **C#**: 5 patterns (class single-line, class opening, method single-line, method opening, closing braces)
+- **Java**: 8 patterns (test annotation, class single-line, class opening, method single-line, method opening, static main single-line, static main opening, closing braces)
+- Java needs 3 additional patterns: 1 for `@Test` annotations, 2 for `static main()` methods
+- Both languages benefit from the same dedenting logic
+
+**Critical implementation insight**: The initial specification estimated 6 patterns for Java, but actual implementation required 8 patterns to handle all variations found in real repository files. Always examine multiple real files before finalizing pattern count.
+
+Notes:
+- Listing order matters. Apply openers before generic closers (as above) to avoid accidentally stripping desired content.
+- Keep patterns intentionally narrow and anchored to reduce false positives.
+- Java's `@Test` annotation pattern should come first to remove it before processing the method declaration
+
+### Runtime Order of Operations (within create_cells)
+
+1) Load `lang_config = load_language_config(language)`
+2) If present, insert a boilerplate cell first
+3) For each parsed block:
+   - Apply `unwrap_code(code, language)` (sequentially over `unwrap_patterns`)
+   - Dedent with `textwrap.dedent(code)` whenever unwrapping is configured for the language
+
+> Note: When language-specific features are enabled, prefer the extended signature `create_cells(parsed_blocks, language)` and the runtime order defined in the Language-Specific Features section (boilerplate → unwrap → dedent → rstrip → skip empty). The simplified example above illustrates the core cell construction only.
+
+   - `rstrip()` to remove trailing whitespace
+   - Skip cell if now empty
+4) Add step metadata if available
+
+This order ensures wrapper removal doesn’t leave code over-indented and avoids generating spurious empty cells.
+
+### Testing Checklist (Language-Specific)
+
+#### General Tests (All Languages)
+- Boilerplate
+  - First cell is boilerplate for languages with `boilerplate` configured
+  - Languages without `boilerplate` configured do not get a boilerplate cell
+- Unwrapping
+  - Class and method wrappers (single-line and multi-line) are removed
+  - Closing braces are removed wherever they appear
+  - Inner content remains and is dedented to column 0
+- Robustness
+  - Missing configuration file → proceed without boilerplate/unwrapping
+  - Malformed regex → warn and continue; no crash
+  - Real repository example file converts correctly end-to-end
+
+#### C#-Specific Tests
+- Test with files from `local_examples/client-specific/dotnet-sync/`
+- Verify NuGet directives appear in first cell
+- Verify `public class ClassName` declarations are removed
+- Verify `public void Run()` method declarations are removed
+- Test both single-line (`public class X {`) and multi-line formats
+- Verify closing braces are removed
+
+#### Java-Specific Tests
+- Test with files from `local_examples/client-specific/jedis/`
+- Test with files from `local_examples/client-specific/lettuce-async/`
+- Test with files from `local_examples/client-specific/lettuce-reactive/`
+- Verify `@Test` annotations are removed
+- Verify `public class ClassName` declarations are removed
+- Verify `public void run()` method declarations are removed
+- Test both single-line (`public class X {`) and multi-line formats
+- Verify closing braces are removed
+- Test files with `main()` methods (if present in examples)
+- Verify code inside wrappers is properly dedented
+
+### Edge Cases and Gotchas
+
+#### General Unwrapping Gotchas
+- Wrappers split across cells: rely on separate opener and generic `}` patterns
+- Dedent all cells when unwrapping is enabled (not only those that changed)
+- Anchoring with `^` is crucial to avoid removing mid-line braces in string literals or comments
+- Apply patterns in a safe order: openers before closers
+- Tabs vs spaces: dedent works on common leading whitespace; prefer spaces in examples
+
+#### Java-Specific Gotchas
+- **Annotations before methods**: Java uses `@Test` annotations that appear on a separate line before the method declaration
+  - Must remove annotation line first, then method declaration
+  - Pattern order matters: `test_annotation` pattern should come before `method_opening` pattern
+- **Method name variations**: Java examples may use `run()`, `main()`, or other method names
+  - Consider using more flexible patterns like `public\\s+void\\s+\\w+\\(\\)` to match any method
+  - Or create separate patterns for common method names
+- **Package declarations**: Some Java files have `package` statements that are already handled by REMOVE blocks
+  - Don't add unwrap patterns for package statements
+- **Import statements**: Java imports are typically in STEP blocks and should be preserved
+  - Don't add unwrap patterns for import statements
+- **Static methods**: Some Java examples use `public static void main(String[] args)`
+  - Need separate pattern to handle `static` keyword and method parameters
+  - Example: `^\\s*public\\s+static\\s+void\\s+main\\(.*\\).*\\{`
+- **Empty lines after class declaration**: Java style often has empty line after class opening brace
+  - The unwrapping logic should handle this naturally by removing the class line and dedenting
+
+
+### Recommended Implementation Strategy
+
+**Phase 1: Boilerplate Injection** (High Priority)
+1. Create `jupyterize_config.json` with C# boilerplate
+2. Load configuration in jupyterize.py
+3. Inject boilerplate as first cell
+4. Test with C# examples
+
+**Phase 2: Structural Unwrapping for C#** (High Priority)
+1. Add C# unwrap_patterns to configuration
+2. Implement pattern-based unwrapping
+3. Test with C# class/method wrappers from `local_examples/client-specific/dotnet-sync/`
+4. Verify indentation handling and dedenting
+
+**Phase 3: Structural Unwrapping for Java** (High Priority)
+1. **FIRST**: Examine 3-4 real Java files from the repository to understand actual patterns:
+   - Look at `local_examples/client-specific/jedis/LandingExample.java`
+   - Look at `local_examples/client-specific/jedis/HomeVecSets.java`
+   - Look at `local_examples/client-specific/lettuce-async/` examples
+   - Look at `local_examples/cmds_hash/lettuce-reactive/` examples
+   - Note: Different files may use `run()` vs `main()`, different brace styles, etc.
+2. Add Java unwrap_patterns to configuration based on what you found (don't assume it's identical to C#)
+3. Test with the same Java examples you examined
+4. Verify `@Test` annotations are removed
+5. Verify both `run()` and `main()` method patterns work
+6. Verify indentation handling and dedenting
+
+**Critical lesson from Java implementation**: The specification initially estimated 6 patterns would be needed, but examining real files revealed that 8 patterns were required (added `static_main_single_line` and `static_main_opening` after seeing `main()` methods in real files). **Always examine real files BEFORE writing patterns.**
+
+**Phase 4: Other Languages** (Lower Priority)
+1. Add Node.js configuration (if needed)
+2. Add other languages (Go, PHP, Rust) as needed
+3. Most of these languages don't have the same structural wrapper issues as C#/Java
+
+### Configuration File Location
+
+**Recommended**: `build/jupyterize/jupyterize_config.json`
+
+**Rationale**:
+- Co-located with jupyterize.py
+- Easy to find and edit
+- Version controlled
+- Can be updated independently of code
+
+### Critical Testing Insight: Always Test with Real Repository Files
+
+**Key Discovery**: Testing with synthetic examples is insufficient. Real repository files revealed edge cases that synthetic tests missed.
+
+**What happened during Java implementation**:
+1. ✅ Created synthetic test with `@Test`, `public class`, `public void run()` - **PASSED**
+2. ✅ Created synthetic test with `public static void main()` - **PASSED**
+3. ⚠️ Tested with real file `LandingExample.java` - **Discovered the test was skipped due to path issues**
+4. 🔧 Fixed path handling to work from both `build/jupyterize/` and repo root
+5. ✅ Re-tested with 4 real files - **All passed, confirmed patterns work in practice**
+
+**Why real files matter**:
+- **Formatting variations**: Real files have inconsistent spacing, blank lines, comments
+- **Multiple patterns in one file**: Real files combine class + method + annotation patterns
+- **Indentation complexity**: Real code has varying indentation levels
+- **Edge cases**: Real files expose issues like split wrappers across cells
+- **Control structures**: Real files contain for loops, foreach loops, if statements with closing braces that must be preserved (see Critical Note #10)
+
+**Recommended testing workflow**:
+1. Write synthetic tests first (fast, focused, easy to debug)
+2. Add at least 1 real file test per language
+3. Test with 3-4 different real files to ensure robustness
+4. Use files from different client libraries (Jedis, Lettuce-async, Lettuce-reactive for Java)
+
+**Implementation tip**: Make real file tests path-aware:
+```python
+def test_java_real_file():
+    # Try both relative paths (from build/jupyterize and from repo root)
+    test_file_options = [
+        'local_examples/client-specific/jedis/LandingExample.java',
+        '../../local_examples/client-specific/jedis/LandingExample.java'
+    ]
+
+    test_file = None
+    for option in test_file_options:
+        if os.path.exists(option):
+            test_file = option
+            break
+
+    if not test_file:
+        print("⚠ Skipping test - file not found")
+        return
+```
+
+**Time saved**: This approach would have saved ~20 minutes of "it works in tests but fails on real files" debugging.
+
+### Testing Requirements
+
+**Boilerplate injection tests**:
+1. C# file → First cell contains NuGet directives
+2. Python file → No boilerplate cell (not configured)
+3. Multiple languages → Each gets correct boilerplate
+
+**Unwrapping tests**:
+1. C# class wrapper → Removed, content kept
+2. C# method wrapper → Removed, content kept
+3. Nested wrappers → Both removed, content kept
+4. Indentation → Correctly adjusted after unwrapping
+
+### Edge Cases
+
+1. **No configuration file**: Tool works normally, no boilerplate/unwrapping
+2. **Language not in config**: Tool works normally for that language
+3. **Empty boilerplate**: No boilerplate cell created
+4. **Empty unwrap_patterns**: No unwrapping performed
+5. **Malformed patterns**: Log warning, skip that pattern
+6. **Nested wrappers**: Process from outermost to innermost
+
+---
+
+## Notebook Generation
+
+### Creating Cells
+
+```python
+from nbformat.v4 import new_code_cell
+
+def create_cells(parsed_blocks):
+    """Convert parsed blocks to notebook cells."""
+    cells = []
+
+    for block in parsed_blocks:
+        code = block['code'].rstrip()
+        if not code.strip():  # Skip empty
+            continue
+
+        cell = new_code_cell(source=code)
+
+        # Add step metadata if present
+        if block['step_name']:
+            cell.metadata['step'] = block['step_name']
+
+        cells.append(cell)
+
+    return cells
+```
+
+### Assembling the Notebook
+
+**Key Implementation Details:**
+
+1. **Use `language.lower()`** when accessing KERNEL_SPECS (keys are lowercase)
+2. **Create output directory** if it doesn't exist before writing
+3. **Handle empty dirname**: `os.path.dirname()` returns empty string for current directory
+
+```python
+from nbformat.v4 import new_notebook
+import nbformat
+
+def create_notebook(cells, language):
+    """Create complete notebook."""
+    nb = new_notebook()
+    nb.cells = cells
+
+    # IMPORTANT: Use .lower() because KERNEL_SPECS keys are lowercase
+    kernel_spec = KERNEL_SPECS[language.lower()]
+
+    nb.metadata.kernelspec = {
+        'display_name': kernel_spec['display_name'],
+        'language': language.lower(),
+        'name': kernel_spec['name']
+    }
+
+    nb.metadata.language_info = {'name': language.lower()}
+
+    return nb
+
+def write_notebook(notebook, output_path):
+    """Write notebook to file."""
+    # Create output directory if needed
+    output_dir = os.path.dirname(output_path)
+    if output_dir and not os.path.exists(output_dir):
+        os.makedirs(output_dir, exist_ok=True)
+
+    # Write notebook
+    with open(output_path, 'w', encoding='utf-8') as f:
+        nbformat.write(notebook, f)
+```
+
+**Common Pitfalls to Avoid:**
+- Forgetting to use `.lower()` when accessing KERNEL_SPECS → KeyError
+- Not creating output directory → FileNotFoundError
+- Not handling empty dirname (current directory case) → Error with `os.makedirs('')`
+
+### Main Function Structure
+
+**Key Implementation Details:**
+
+1. **Separate conversion logic** from CLI - create a `jupyterize()` function that can be imported
+2. **Set up logging early** - before any operations
+3. **Determine output path** - default to same name with `.ipynb` extension
+4. **Wrap in try/except** - catch and log errors gracefully
+
+```python
+def jupyterize(input_file, output_file=None, verbose=False):
+    """
+    Convert code example file to Jupyter notebook.
+
+    This function can be imported and used programmatically.
+    """
+    # Set up logging
+    log_level = logging.DEBUG if verbose else logging.INFO
+    logging.basicConfig(level=log_level, format='%(levelname)s: %(message)s')
+
+    # Determine output file
+    if not output_file:
+        base, _ = os.path.splitext(input_file)
+        output_file = f"{base}.ipynb"
+
+    logging.info(f"Converting {input_file} to {output_file}")
+
+    try:
+        # 1. Detect language
+        language = detect_language(input_file)
+
+        # 2. Validate input
+        validate_input(input_file, language)
+
+        # 3. Parse file
+        parsed_blocks = parse_file(input_file, language)
+
+        # 4. Create cells
+        cells = create_cells(parsed_blocks)
+
+        # 5. Create notebook
+        notebook = create_notebook(cells, language)
+
+        # 6. Write to file
+        write_notebook(notebook, output_file)
+
+        logging.info("Conversion completed successfully")
+        return output_file
+
+    except Exception as e:
+        logging.error(f"Conversion failed: {e}")
+        raise
+
+def main():
+    """Main entry point for command-line usage."""
+    parser = argparse.ArgumentParser(
+        description='Convert code example files to Jupyter notebooks'
+    )
+    parser.add_argument('input_file', help='Input code example file')
+    parser.add_argument('-o', '--output', dest='output_file',
+                       help='Output notebook file path')
+    parser.add_argument('-v', '--verbose', action='store_true',
+                       help='Enable verbose logging')
+
+    args = parser.parse_args()
+
+    try:
+        output_file = jupyterize(args.input_file, args.output_file, args.verbose)
+        print(f"Successfully created: {output_file}")
+        return 0
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+if __name__ == '__main__':
+    sys.exit(main())
+```
+
+---
+
+## Error Handling
+
+> **📖 For marker validation rules**, see `build/tcedocs/SPECIFICATION.md` section "Troubleshooting" (lines 1462-1659).
+
+### Input Validation
+
+**Critical checks** (raise errors):
+1. File exists
+2. Supported file extension
+3. First line contains `EXAMPLE:` marker (with correct comment prefix)
+
+**Implementation**:
+```python
+def validate_input(file_path, language):
+    """Validate input file."""
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"Input file not found: {file_path}")
+
+    # Check EXAMPLE marker using helper
+    prefix = PREFIXES[language.lower()]
+    with open(file_path, 'r') as f:
+        first_line = f.readline()
+    if not _check_marker(first_line, prefix, EXAMPLE):
+        raise ValueError(
+            f"File must start with '{prefix} EXAMPLE: <id>' marker\n"
+            f"First line: {first_line.strip()}"
+        )
+```
+
+### Edge Cases to Handle
+
+**Non-critical issues** (warn, don't error):
+1. **Duplicate step names**: Warn but create both cells
+2. **Nested markers**: Warn about potential issues
+3. **Unclosed markers**: Warn but continue processing
+
+**Silent handling** (no warning needed):
+1. **Empty cells**: Skip cells with no code (after stripping whitespace)
+2. **No steps**: File with only preamble → single cell
+3. **Only REMOVE blocks**: Generate notebook with no cells (valid but unusual)
+
+---
+
+## Testing
+
+### Add-a-Language Checklist (Minimum)
+
+- Identify the language’s file extensions and confirm mapping in `EXTENSION_TO_LANGUAGE`
+- Examine 3–4 real repository files for that language (different clients/flavors)
+- Start with C# unwrap patterns; add/adjust for language specifics (e.g., annotations, static main)
+- Add boilerplate if required by the notebook kernel; leave empty if unclear
+- Write 1–2 synthetic unit tests (annotation removal, method/class wrappers, dedent)
+- Add 1 real-file integration test per client variant; make path resolution robust
+- Verify clean notebooks (no wrappers), correct kernelspec, correct cell boundaries
+- Document the final patterns and ordering in the configuration comments/descriptions
+
+### Test Categories
+
+**1. Unit Tests**
+- Language detection from file extensions
+- Kernel specification mapping
+
+- Marker detection in lines (including helper function)
+- Cell creation from code blocks
+
+**2. Integration Tests**
+- End-to-end conversion of sample files
+- Validation of generated notebook structure
+- Testing with real example files from `local_examples/`
+
+**3. Edge Case Tests** (Critical - often overlooked!)
+- Files with no steps (only preamble)
+- Files with only REMOVE blocks
+- Empty steps
+- HIDE blocks (should be included)
+- **Marker format variations** (with/without space)
+- **Duplicate step names** (should warn)
+- **Nested markers** (should warn)
+- **Missing EXAMPLE marker** (should error)
+
+> Note: Examples below are abbreviated for brevity. See full tests in `build/jupyterize/test_jupyterize.py`.
+
+**4. Language-Specific Feature Tests** (New!)
+- **Boilerplate injection**: C# gets NuGet directives as first cell
+- **Structural unwrapping**: C# class/method wrappers removed
+- **Indentation handling**: Code properly dedented after unwrapping
+- **Configuration loading**: Missing config handled gracefully
+- **Multiple languages**: Each language gets correct boilerplate
+
+### Essential Edge Case Tests
+
+These tests catch common real-world issues:
+
+#### 1. Marker Format Variations
+```python
+def test_marker_format_variations():
+    """Test markers without space after comment prefix."""
+    test_content = """#EXAMPLE: test_no_space
+import redis
+
+
+#STEP_START connect
+r = redis.Redis()
+#STEP_END
+"""
+    # Should parse correctly despite no space after #
+```
+
+> Note: Real files may have inconsistent formatting.
+
+#### 2. Duplicate Step Names
+```python
+def test_duplicate_step_names():
+    """Test warning for duplicate step names."""
+    test_content = """# EXAMPLE: test
+# STEP_START connect
+r = redis.Redis()
+# STEP_END
+
+# STEP_START connect
+r.ping()
+# STEP_END
+"""
+    # Should warn but still create both cells
+```
+
+> Note: Catches copy-paste errors in example files.
+
+#### 3. No Steps File
+```python
+def test_no_steps_file():
+    """Test file with only preamble."""
+    test_content = """# EXAMPLE: no_steps
+import redis
+r = redis.Redis()
+"""
+    # Should create single preamble cell
+```
+
+> Note: Not all examples need steps; common pattern.
+
+#### 4. Nested Markers
+```python
+def test_nested_markers():
+    """Test nested REMOVE blocks."""
+    test_content = """# EXAMPLE: nested
+# REMOVE_START
+# REMOVE_START
+code
+# REMOVE_END
+# REMOVE_END
+"""
+    # Should warn but still process
+```
+
+> Note: Validates warning system for malformed files.
+
+#### 5. Boilerplate Injection (C#)
+```python
+def test_csharp_boilerplate_injection():
+    # See full test: build/jupyterize/test_jupyterize.py
+    # Asserts first cell is NuGet boilerplate in C# notebooks
+```
+
+> Note: C# notebooks need NuGet directives to download dependencies.
+
+#### 6. Structural Unwrapping (C#)
+```python
+def test_csharp_unwrapping():
+    # See full test: build/jupyterize/test_jupyterize.py
+    # Asserts class/method wrappers are removed; code remains
+```
+
+> Note: Test framework wrappers shouldn't appear in notebooks.
+
+### Example Test
+
+```python
+def test_basic_conversion():
+    # See full test: build/jupyterize/test_jupyterize.py
+    # Asserts 2 cells (preamble + step) and correct kernelspec
+```
+
+---
+
+## Implementation Checklist
+
+**Core Functionality:**
+- [ ] Command-line argument parsing (`-o`, `-v`, `-h`)
+- [ ] Language detection from file extension
+- [ ] Marker parsing (line-by-line with regex)
+- [ ] Cell generation from parsed blocks
+- [ ] Notebook assembly and file writing
+
+**Quality:**
+- [ ] Input validation (file exists, supported extension, EXAMPLE marker)
+- [ ] Error handling with helpful messages
+- [ ] Verbose logging for debugging
+- [ ] Unit and integration tests
+- [ ] Test with real files from `local_examples/`
+
+---
+
+## References
+
+- **User guide**: `build/jupyterize/README.md`
+- **Example format**: `build/tcedocs/README.md` and `build/tcedocs/SPECIFICATION.md`
+- **Existing constants**: `build/components/example.py` (PREFIXES, marker names)
+- **Language mappings**: `build/local_examples.py` (EXTENSION_TO_LANGUAGE)
+- **nbformat docs**: https://nbformat.readthedocs.io/
+
+---
+
+## Specification Evolution
+
+This specification has been iteratively improved based on real implementation experience:
+
+### Version 1: Initial Specification
+- Basic structure and code examples
+- Core mappings and algorithms
+- ~430 lines
+
+### Version 2: After First Implementation
+- Added "Critical Implementation Notes" section
+- Highlighted case sensitivity issues
+- Added common pitfalls after each code block
+- Enhanced import strategy
+- Added main function structure
+- ~540 lines
+
+### Version 3: After Code Improvements
+- Added "Code Quality Patterns" section
+- Emphasized helper function pattern for repeated conditionals
+- Added duplicate step name tracking
+- Enhanced testing section with essential edge cases
+- Added concrete test examples for each edge case
+- ~890 lines
+
+### Version 4: After C# Language-Specific Features
+- Added "Language-Specific Features" section
+- Documented boilerplate injection and structural unwrapping
+- Added C# configuration examples with 5 unwrap patterns
+- Added implementation notes for pattern-based unwrapping
+- Enhanced Critical Implementation Notes with unwrapping details
+- ~1400 lines
+
+### Version 5: After Java Implementation
+- Added Java configuration examples with 8 unwrap patterns
+- Added Critical Implementation Note #11: Pattern count differences between languages
+- Added "Critical Testing Insight" section about testing with real repository files
+- Updated Phase 3 implementation strategy with "examine real files first" guidance
+- Corrected Java pattern count from initial estimate (6) to actual implementation (8)
+- Added insights about pattern order importance in Java (`@Test` before methods)
+- ~1720 lines
+
+### Version 6: After Closing Brace Bug Fix
+- Added Critical Implementation Note #10: Closing brace removal must be match-based, not pattern-based
+- Fixed critical bug where control structure closing braces (for, foreach, if) were incorrectly removed
+- Modified `remove_matching_lines()` to return `(code, match_count)` tuple
+- Updated `unwrap_code()` to track braces based on actual matches, not pattern configuration
+- Removed `closing_braces` pattern from C# and Java configurations (now handled programmatically)
+- Added regression test `test_csharp_for_loop_braces()` to prevent future occurrences
+- Updated "Critical Testing Insight" to mention control structure edge case
+- **Follow-up fix**: Added filter to skip cells containing only orphaned closing braces
+- Enhanced regression test to verify no orphaned closing brace cells exist
+- **Boilerplate update**: Removed version numbers from C# NuGet directives (defaults to latest)
+- ~1805 lines
+
+### Key Lessons Learned
+
+1. **Lead with pitfalls**: Critical notes at the beginning save hours of debugging
+2. **Show refactoring patterns**: Don't just show the final code, explain why it's structured that way
+3. **Helper functions are essential**: Repeated conditionals should be extracted immediately
+4. **Edge cases need examples**: Don't just list them, show test code
+5. **Warnings vs errors**: Distinguish between critical and non-critical issues
+6. **Test-driven specification**: Include test examples alongside implementation examples
+7. **Examine real files first**: Don't estimate pattern counts - look at actual repository files before implementation
+8. **Test with real files**: Synthetic tests are insufficient; real files reveal edge cases
+9. **Pattern counts vary**: Don't assume similar languages need identical pattern counts (C# needs 5, Java needs 8)
+10. **Document actual implementation**: Update specification with what was actually implemented, not just what was planned
+
+### What Makes This Specification Effective
+
+✅ **Pitfalls first**: Critical notes before implementation details
+✅ **Code quality patterns**: Explains the "why" behind refactoring
+✅ **Helper functions**: Shows how to avoid duplication
+✅ **Comprehensive testing**: Includes edge case test examples
+✅ **Real-world focus**: Based on actual implementation experience
+✅ **Iterative improvement**: Updated based on lessons learned
+
+### Estimated Time Savings
+
+**For initial tool implementation**:
+- **Without specification**: ~4-6 hours (trial and error)
+- **With v1 specification**: ~2 hours (basic guidance)
+- **With v2 specification**: ~1 hour (pitfalls highlighted)
+- **With v3 specification**: ~30-45 minutes (patterns + tests included)
+
+**For adding new language support (Java example)**:
+- **Without v5 specification**: ~2-3 hours (trial and error, pattern discovery, debugging)
+- **With v5 specification**: ~15-20 minutes (examine files, copy C# patterns, add extras, test)
+  - 5 minutes: Examine 3-4 real Java files
+  - 5 minutes: Copy C# patterns and add Java-specific patterns
+  - 5 minutes: Write tests
+  - 5 minutes: Test with real files and verify
+
+**Total improvement**:
+- Initial implementation: ~85% time reduction (6 hours → 45 minutes)
+- New language addition: ~90% time reduction (2.5 hours → 20 minutes)
+- **With v3 specification**: ~30-45 minutes (patterns + tests included)
+
+**Total improvement**: ~85% time reduction from no spec to v3 spec
+
diff --git a/build/jupyterize/jupyterize.py b/build/jupyterize/jupyterize.py
new file mode 100755
index 000000000..0dad211d2
--- /dev/null
+++ b/build/jupyterize/jupyterize.py
@@ -0,0 +1,755 @@
+#!/usr/bin/env python3
+"""
+Jupyterize - Convert code example files to Jupyter notebooks
+
+This tool converts code example files (with special comment markers) into
+Jupyter notebook (.ipynb) files. It automatically detects the programming
+language from the file extension and handles marker processing.
+
+Usage:
+    python jupyterize.py <input_file> [options]
+
+Options:
+    -o, --output <file>  Output notebook file path
+    -v, --verbose        Enable verbose logging
+    -h, --help          Show help message
+"""
+
+import argparse
+import json
+import logging
+import os
+import re
+import sys
+import textwrap
+import nbformat
+from nbformat.v4 import new_notebook, new_code_cell
+
+# Add parent directory to path to import from build/
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+# Import existing mappings
+try:
+    from local_examples import EXTENSION_TO_LANGUAGE
+    from components.example import PREFIXES
+except ImportError as e:
+    print(f"Error importing required modules: {e}", file=sys.stderr)
+    print("Make sure you're running this from the docs repository root.", file=sys.stderr)
+    sys.exit(1)
+
+# Marker constants (from build/components/example.py)
+HIDE_START = 'HIDE_START'
+HIDE_END = 'HIDE_END'
+REMOVE_START = 'REMOVE_START'
+REMOVE_END = 'REMOVE_END'
+STEP_START = 'STEP_START'
+STEP_END = 'STEP_END'
+EXAMPLE = 'EXAMPLE:'
+BINDER_ID = 'BINDER_ID'
+
+# Jupyter kernel specifications
+KERNEL_SPECS = {
+    'python': {'name': 'python3', 'display_name': 'Python 3'},
+    'node.js': {'name': 'javascript', 'display_name': 'JavaScript (Node.js)'},
+    'go': {'name': 'gophernotes', 'display_name': 'Go'},
+    'c#': {'name': 'csharp', 'display_name': 'C#'},
+    'java': {'name': 'java', 'display_name': 'Java'},
+    'php': {'name': 'php', 'display_name': 'PHP'},
+    'rust': {'name': 'rust', 'display_name': 'Rust'}
+}
+
+
+def _check_marker(line, prefix, marker):
+    """
+    Check if a line contains a marker (with or without space after prefix).
+
+    Args:
+        line: Line to check
+        prefix: Comment prefix (e.g., '#', '//')
+        marker: Marker to look for (e.g., 'EXAMPLE:', 'STEP_START')
+
+    Returns:
+        bool: True if marker is found
+    """
+    return f'{prefix} {marker}' in line or f'{prefix}{marker}' in line
+
+
+def load_language_config(language):
+    """
+    Load language-specific configuration from jupyterize_config.json.
+
+    Args:
+        language: Language name (e.g., 'python', 'c#')
+
+    Returns:
+        dict: Configuration for the language, or empty dict if not found
+    """
+    config_file = os.path.join(os.path.dirname(__file__), 'jupyterize_config.json')
+    if not os.path.exists(config_file):
+        logging.debug(f"Configuration file not found: {config_file}")
+        return {}
+
+    try:
+        with open(config_file, 'r', encoding='utf-8') as f:
+            config = json.load(f)
+        return config.get(language.lower(), {})
+    except json.JSONDecodeError as e:
+        logging.warning(f"Failed to parse configuration file: {e}")
+        return {}
+    except Exception as e:
+        logging.warning(f"Error loading configuration: {e}")
+        return {}
+
+
+def remove_wrapper_keep_content(code, start_pattern, end_pattern):
+    """
+    Remove wrapper lines but keep content between them.
+
+    Args:
+        code: Source code as string
+        start_pattern: Regex pattern for wrapper start
+        end_pattern: Regex pattern for wrapper end
+
+    Returns:
+        str: Code with wrappers removed and content dedented
+    """
+    lines = code.split('\n')
+    result = []
+    in_wrapper = False
+    wrapper_indent = 0
+    skip_next_empty = False
+
+    for i, line in enumerate(lines):
+        # Check for wrapper start
+        if re.match(start_pattern, line):
+            in_wrapper = True
+            wrapper_indent = len(line) - len(line.lstrip())
+            skip_next_empty = True
+            continue  # Skip wrapper start line
+
+        # Check for wrapper end
+        if in_wrapper and re.match(end_pattern, line):
+            in_wrapper = False
+            skip_next_empty = True
+            continue  # Skip wrapper end line
+
+        # Skip empty line immediately after wrapper start/end
+        if skip_next_empty and not line.strip():
+            skip_next_empty = False
+            continue
+
+        skip_next_empty = False
+
+        # Process content inside wrapper
+        if in_wrapper:
+            # Remove wrapper indentation (typically 4 spaces)
+            if line.startswith(' ' * (wrapper_indent + 4)):
+                result.append(line[wrapper_indent + 4:])
+            elif line.strip():  # Non-empty line with different indentation
+                result.append(line.lstrip())
+            else:  # Empty line
+                result.append(line)
+        else:
+            result.append(line)
+
+    return '\n'.join(result)
+
+
+def remove_matching_lines(code, start_pattern, end_pattern):
+    """
+    Remove lines matching patterns (including the matched lines).
+
+    Args:
+        code: Source code as string
+        start_pattern: Regex pattern for start line
+        end_pattern: Regex pattern for end line
+
+    Returns:
+        tuple: (modified_code, match_count) where match_count is the number
+               of times the pattern was matched
+    """
+    lines = code.split('\n')
+    result = []
+    in_match = False
+    single_line_pattern = (start_pattern == end_pattern)
+    match_count = 0
+
+    for line in lines:
+        # Check for start pattern
+        if re.match(start_pattern, line):
+            match_count += 1
+            if single_line_pattern:
+                # For single-line patterns, just skip this line
+                continue
+            else:
+                # For multi-line patterns, enter match mode
+                in_match = True
+                continue  # Skip this line
+
+        # Check for end pattern (only for multi-line patterns)
+        if in_match and re.match(end_pattern, line):
+            in_match = False
+            continue  # Skip this line
+
+        # Keep line if not in match
+        if not in_match:
+            result.append(line)
+
+    return '\n'.join(result), match_count
+
+
+
+def remove_trailing_braces(code, count):
+    """
+    Remove a specific number of closing braces from the end of the code.
+
+    This is used after unwrapping class/method wrappers to remove only
+    the closing braces that correspond to the removed opening braces,
+    while preserving closing braces from control structures (for, foreach, if, etc.).
+
+    Args:
+        code: Source code as string
+        count: Number of closing braces to remove from the end
+
+    Returns:
+        str: Code with trailing closing braces removed
+    """
+    if count <= 0:
+        return code
+
+    lines = code.split('\n')
+    removed = 0
+
+    # Scan from the end, removing lines that are only closing braces
+    for i in range(len(lines) - 1, -1, -1):
+        if removed >= count:
+            break
+
+        # Check if this line is only whitespace and a closing brace
+        if re.match(r'^\s*\}\s*$', lines[i]):
+            lines[i] = None  # Mark for removal
+            removed += 1
+
+    # Filter out marked lines
+    result = [line for line in lines if line is not None]
+
+    return '\n'.join(result)
+
+
+def unwrap_code(code, language):
+    """
+    Remove language-specific structural wrappers from code.
+
+    Args:
+        code: Source code as string
+        language: Language name (e.g., 'c#')
+
+    Returns:
+        str: Code with structural wrappers removed
+    """
+    lang_config = load_language_config(language)
+    unwrap_patterns = lang_config.get('unwrap_patterns', [])
+
+    if not unwrap_patterns:
+        return code
+
+    # Track how many opening braces we removed (for closing brace removal)
+    braces_removed = 0
+
+    # Apply each unwrap pattern
+    for pattern_config in unwrap_patterns:
+        try:
+            pattern_type = pattern_config.get('type', 'unknown')
+
+            # Skip the closing_braces pattern - we'll handle it specially
+            if pattern_type == 'closing_braces':
+                continue
+
+            keep_content = pattern_config.get('keep_content', True)
+
+            if keep_content:
+                # Remove wrapper but keep content
+                code = remove_wrapper_keep_content(
+                    code,
+                    pattern_config['pattern'],
+                    pattern_config['end_pattern']
+                )
+                # For keep_content patterns, we don't track braces
+                match_count = 0
+            else:
+                # Remove entire matched section
+                code, match_count = remove_matching_lines(
+                    code,
+                    pattern_config['pattern'],
+                    pattern_config['end_pattern']
+                )
+
+            # Count opening braces removed (only if pattern actually matched)
+            # For class/method patterns, we remove one opening brace per match
+            # Single-line patterns: opening brace is in the pattern itself
+            # Multi-line patterns: opening brace is in the end_pattern
+            if match_count > 0:
+                if '{' in pattern_config['pattern'] or '{' in pattern_config.get('end_pattern', ''):
+                    braces_removed += match_count
+
+            if match_count > 0:
+                logging.debug(
+                    f"Applied unwrap pattern: {pattern_type} ({match_count} matches)"
+                )
+        except KeyError as e:
+            logging.warning(
+                f"Malformed unwrap pattern (missing {e}), skipping"
+            )
+        except re.error as e:
+            logging.warning(
+                f"Invalid regex pattern: {e}, skipping"
+            )
+
+    # Remove the corresponding number of closing braces from the end
+    if braces_removed > 0:
+        logging.debug(f"Removing {braces_removed} trailing closing braces")
+        code = remove_trailing_braces(code, braces_removed)
+
+    return code
+
+
+def detect_language(file_path):
+    """
+    Detect programming language from file extension.
+
+    Args:
+        file_path: Path to the input file
+
+    Returns:
+        str: Language name (e.g., 'python', 'node.js')
+
+    Raises:
+        ValueError: If file extension is not supported
+    """
+    _, ext = os.path.splitext(file_path)
+    language = EXTENSION_TO_LANGUAGE.get(ext.lower())
+
+    if not language:
+        supported = ', '.join(sorted(EXTENSION_TO_LANGUAGE.keys()))
+        raise ValueError(
+            f"Unsupported file extension: {ext}\n"
+            f"Supported extensions: {supported}"
+        )
+
+    logging.info(f"Detected language: {language} (from extension {ext})")
+    return language
+
+
+def validate_input(file_path, language):
+    """
+    Validate input file.
+
+    Args:
+        file_path: Path to the input file
+        language: Detected language
+
+    Raises:
+        FileNotFoundError: If file doesn't exist
+        ValueError: If file is invalid
+    """
+    # Check file exists
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"Input file not found: {file_path}")
+
+    if not os.path.isfile(file_path):
+        raise ValueError(f"Path is not a file: {file_path}")
+
+    # Check EXAMPLE marker
+    prefix = PREFIXES.get(language.lower())
+    if not prefix:
+        raise ValueError(f"Unknown comment prefix for language: {language}")
+
+    with open(file_path, 'r', encoding='utf-8') as f:
+        first_line = f.readline()
+
+    if not _check_marker(first_line, prefix, EXAMPLE):
+        raise ValueError(
+            f"File must start with '{prefix} {EXAMPLE} <id>' marker\n"
+            f"First line: {first_line.strip()}"
+        )
+
+    logging.info(f"Input file validated: {file_path}")
+
+
+def parse_file(file_path, language):
+    """
+    Parse file and extract cells.
+
+    Args:
+        file_path: Path to the input file
+        language: Programming language
+
+    Returns:
+        list: List of dicts with 'code' and 'step_name' keys
+    """
+    with open(file_path, 'r', encoding='utf-8') as f:
+        lines = f.readlines()
+
+    prefix = PREFIXES[language.lower()]
+
+    # State tracking
+    in_remove = False
+    in_step = False
+    step_name = None
+    step_lines = []
+    preamble_lines = []
+    cells = []
+    seen_step_names = set()  # Track duplicate step names
+
+    logging.debug(f"Parsing {len(lines)} lines with comment prefix '{prefix}'")
+
+    for line_num, line in enumerate(lines, 1):
+        # Skip metadata markers
+        if _check_marker(line, prefix, EXAMPLE):
+            logging.debug(f"Line {line_num}: Skipping EXAMPLE marker")
+            continue
+
+        if _check_marker(line, prefix, BINDER_ID):
+            logging.debug(f"Line {line_num}: Skipping BINDER_ID marker")
+            continue
+
+        # Handle REMOVE blocks
+        if _check_marker(line, prefix, REMOVE_START):
+            if in_remove:
+                logging.warning(f"Line {line_num}: Nested REMOVE_START detected")
+            in_remove = True
+            logging.debug(f"Line {line_num}: Entering REMOVE block")
+            continue
+
+        if _check_marker(line, prefix, REMOVE_END):
+            if not in_remove:
+                logging.warning(f"Line {line_num}: REMOVE_END without REMOVE_START")
+            in_remove = False
+            logging.debug(f"Line {line_num}: Exiting REMOVE block")
+            continue
+
+        if in_remove:
+            continue
+
+        # Skip HIDE markers (but include content)
+        if _check_marker(line, prefix, HIDE_START):
+            logging.debug(f"Line {line_num}: Skipping HIDE_START marker (content will be included)")
+            continue
+
+        if _check_marker(line, prefix, HIDE_END):
+            logging.debug(f"Line {line_num}: Skipping HIDE_END marker")
+            continue
+
+        # Handle STEP blocks
+        if _check_marker(line, prefix, STEP_START):
+            if in_step:
+                logging.warning(f"Line {line_num}: Nested STEP_START detected")
+
+            # Save preamble if exists
+            if preamble_lines:
+                preamble_code = ''.join(preamble_lines)
+                cells.append({'code': preamble_code, 'step_name': None})
+                logging.debug(f"Saved preamble cell ({len(preamble_lines)} lines)")
+                preamble_lines = []
+
+            in_step = True
+            # Extract step name
+            if STEP_START in line:
+                step_name = line.split(STEP_START)[1].strip()
+
+                # Check for duplicate step names
+                if step_name and step_name in seen_step_names:
+                    logging.warning(
+                        f"Line {line_num}: Duplicate step name '{step_name}' "
+                        f"(previously defined)"
+                    )
+                elif step_name:
+                    seen_step_names.add(step_name)
+
+                logging.debug(f"Line {line_num}: Starting step '{step_name}'")
+            else:
+                step_name = None
+                logging.debug(f"Line {line_num}: Starting unnamed step")
+            step_lines = []
+            continue
+
+        if _check_marker(line, prefix, STEP_END):
+            if not in_step:
+                logging.warning(f"Line {line_num}: STEP_END without STEP_START")
+
+            if step_lines:
+                step_code = ''.join(step_lines)
+                cells.append({'code': step_code, 'step_name': step_name})
+                logging.debug(f"Saved step cell '{step_name}' ({len(step_lines)} lines)")
+
+            in_step = False
+            step_name = None
+            step_lines = []
+            continue
+
+        # Collect code
+        if in_step:
+            step_lines.append(line)
+        else:
+            preamble_lines.append(line)
+
+    # Save remaining preamble
+    if preamble_lines:
+        preamble_code = ''.join(preamble_lines)
+        cells.append({'code': preamble_code, 'step_name': None})
+        logging.debug(f"Saved final preamble cell ({len(preamble_lines)} lines)")
+
+    # Check for unclosed blocks
+    if in_remove:
+        logging.warning("File ended with unclosed REMOVE block")
+    if in_step:
+        logging.warning("File ended with unclosed STEP block")
+
+    logging.info(f"Parsed {len(cells)} cells from file")
+    return cells
+
+
+def create_cells(parsed_blocks, language):
+    """
+    Convert parsed blocks to notebook cells.
+
+    Args:
+        parsed_blocks: List of dicts with 'code' and 'step_name'
+        language: Programming language (for boilerplate injection and unwrapping)
+
+    Returns:
+        list: List of nbformat cell objects
+    """
+    cells = []
+
+    # Get language configuration
+    lang_config = load_language_config(language)
+
+    # Add boilerplate cell if defined
+    boilerplate = lang_config.get('boilerplate', [])
+    if boilerplate:
+        boilerplate_code = '\n'.join(boilerplate)
+        boilerplate_cell = new_code_cell(source=boilerplate_code)
+        boilerplate_cell.metadata['cell_type'] = 'boilerplate'
+        boilerplate_cell.metadata['language'] = language
+        cells.append(boilerplate_cell)
+        logging.info(f"Added boilerplate cell for {language} ({len(boilerplate)} lines)")
+
+    # Process regular cells
+    for i, block in enumerate(parsed_blocks):
+        code = block['code']
+
+        # Apply unwrapping if configured
+        if lang_config.get('unwrap_patterns'):
+            original_code = code
+            code = unwrap_code(code, language)
+            if code != original_code:
+                logging.debug(f"Applied unwrapping to cell {i}")
+
+        # Dedent code if unwrap patterns are configured
+        # (code may have been indented inside wrappers)
+        if lang_config.get('unwrap_patterns'):
+            code = textwrap.dedent(code)
+
+        # Strip trailing whitespace
+        code = code.rstrip()
+
+        # Skip empty cells
+        if not code.strip():
+            logging.debug(f"Skipping empty cell {i}")
+            continue
+
+        # Skip cells that contain only closing braces and whitespace
+        # (orphaned closing braces from removed class/method wrappers)
+        if lang_config.get('unwrap_patterns'):
+            # Remove all whitespace and check if only closing braces remain
+            code_no_whitespace = re.sub(r'\s', '', code)
+            if code_no_whitespace and re.match(r'^}+$', code_no_whitespace):
+                logging.debug(f"Skipping cell {i} (contains only closing braces)")
+                continue
+
+        # Create code cell
+        cell = new_code_cell(source=code)
+
+        # Add step metadata if present
+        if block['step_name']:
+            cell.metadata['step'] = block['step_name']
+            logging.debug(f"Created cell {i} with step '{block['step_name']}'")
+        else:
+            logging.debug(f"Created cell {i} (preamble)")
+
+        cells.append(cell)
+
+    logging.info(f"Created {len(cells)} notebook cells")
+    return cells
+
+
+def create_notebook(cells, language):
+    """
+    Create complete Jupyter notebook.
+
+    Args:
+        cells: List of nbformat cell objects
+        language: Programming language
+
+    Returns:
+        nbformat.NotebookNode: Complete notebook
+    """
+    nb = new_notebook()
+    nb.cells = cells
+
+    # Set kernel metadata
+    kernel_spec = KERNEL_SPECS.get(language.lower())
+    if not kernel_spec:
+        raise ValueError(f"No kernel specification for language: {language}")
+
+    nb.metadata.kernelspec = {
+        'display_name': kernel_spec['display_name'],
+        'language': language.lower(),
+        'name': kernel_spec['name']
+    }
+
+    nb.metadata.language_info = {
+        'name': language.lower()
+    }
+
+    logging.info(f"Created notebook with kernel: {kernel_spec['name']}")
+    return nb
+
+
+def write_notebook(notebook, output_path):
+    """
+    Write notebook to file.
+
+    Args:
+        notebook: nbformat.NotebookNode object
+        output_path: Output file path
+    """
+    # Create output directory if needed
+    output_dir = os.path.dirname(output_path)
+    if output_dir and not os.path.exists(output_dir):
+        os.makedirs(output_dir, exist_ok=True)
+        logging.debug(f"Created output directory: {output_dir}")
+
+    # Write notebook
+    try:
+        with open(output_path, 'w', encoding='utf-8') as f:
+            nbformat.write(notebook, f)
+        logging.info(f"Wrote notebook to: {output_path}")
+    except IOError as e:
+        raise IOError(f"Failed to write notebook: {e}")
+
+
+def jupyterize(input_file, output_file=None, verbose=False):
+    """
+    Convert code example file to Jupyter notebook.
+
+    Args:
+        input_file: Path to input file
+        output_file: Path to output file (default: same name with .ipynb extension)
+        verbose: Enable verbose logging
+
+    Returns:
+        str: Path to output file
+    """
+    # Set up logging
+    log_level = logging.DEBUG if verbose else logging.INFO
+    logging.basicConfig(
+        level=log_level,
+        format='%(levelname)s: %(message)s'
+    )
+
+    # Determine output file
+    if not output_file:
+        base, _ = os.path.splitext(input_file)
+        output_file = f"{base}.ipynb"
+
+    logging.info(f"Converting {input_file} to {output_file}")
+
+    try:
+        # Detect language
+        language = detect_language(input_file)
+
+        # Validate input
+        validate_input(input_file, language)
+
+        # Parse file
+        parsed_blocks = parse_file(input_file, language)
+
+        if not parsed_blocks:
+            logging.warning("No code blocks found in file")
+
+        # Create cells (with language-specific boilerplate and unwrapping)
+        cells = create_cells(parsed_blocks, language)
+
+        if not cells:
+            logging.warning("No cells created (all code may be in REMOVE blocks)")
+
+        # Create notebook
+        notebook = create_notebook(cells, language)
+
+        # Write to file
+        write_notebook(notebook, output_file)
+
+        logging.info("Conversion completed successfully")
+        return output_file
+
+    except Exception as e:
+        logging.error(f"Conversion failed: {e}")
+        raise
+
+
+def main():
+    """Main entry point for command-line usage."""
+    parser = argparse.ArgumentParser(
+        description='Convert code example files to Jupyter notebooks',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python jupyterize.py example.py
+  python jupyterize.py example.py -o output.ipynb
+  python jupyterize.py example.py -v
+
+The tool automatically:
+  - Detects language from file extension
+  - Excludes EXAMPLE: and BINDER_ID markers
+  - Includes code in HIDE_START/HIDE_END blocks
+  - Excludes code in REMOVE_START/REMOVE_END blocks
+  - Creates separate cells for each STEP_START/STEP_END block
+        """
+    )
+
+    parser.add_argument(
+        'input_file',
+        help='Input code example file'
+    )
+
+    parser.add_argument(
+        '-o', '--output',
+        dest='output_file',
+        help='Output notebook file path (default: same name with .ipynb extension)'
+    )
+
+    parser.add_argument(
+        '-v', '--verbose',
+        action='store_true',
+        help='Enable verbose logging'
+    )
+
+    args = parser.parse_args()
+
+    try:
+        output_file = jupyterize(
+            args.input_file,
+            args.output_file,
+            args.verbose
+        )
+        print(f"Successfully created: {output_file}")
+        return 0
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == '__main__':
+    sys.exit(main())
diff --git a/build/jupyterize/jupyterize_config.json b/build/jupyterize/jupyterize_config.json
new file mode 100644
index 000000000..b307dbd5c
--- /dev/null
+++ b/build/jupyterize/jupyterize_config.json
@@ -0,0 +1,113 @@
+{
+  "c#": {
+    "boilerplate": [
+      "#r \"nuget: NRedisStack\"",
+      "#r \"nuget: StackExchange.Redis\""
+    ],
+    "unwrap_patterns": [
+      {
+        "type": "class_single_line",
+        "pattern": "^\\s*public\\s+class\\s+\\w+.*\\{\\s*$",
+        "end_pattern": "^\\s*public\\s+class\\s+\\w+.*\\{\\s*$",
+        "keep_content": false,
+        "description": "Remove public class declaration with opening brace on same line"
+      },
+      {
+        "type": "class_opening",
+        "pattern": "^\\s*public\\s+class\\s+\\w+",
+        "end_pattern": "^\\s*\\{\\s*$",
+        "keep_content": false,
+        "description": "Remove public class declaration and opening brace on separate lines"
+      },
+      {
+        "type": "method_single_line",
+        "pattern": "^\\s*public\\s+void\\s+Run\\(\\).*\\{\\s*$",
+        "end_pattern": "^\\s*public\\s+void\\s+Run\\(\\).*\\{\\s*$",
+        "keep_content": false,
+        "description": "Remove public void Run() with opening brace on same line"
+      },
+      {
+        "type": "method_opening",
+        "pattern": "^\\s*public\\s+void\\s+Run\\(\\)",
+        "end_pattern": "^\\s*\\{\\s*$",
+        "keep_content": false,
+        "description": "Remove public void Run() declaration and opening brace on separate lines"
+      }
+    ]
+  },
+  "python": {
+    "boilerplate": [],
+    "unwrap_patterns": []
+  },
+  "node.js": {
+    "boilerplate": [],
+    "unwrap_patterns": []
+  },
+  "go": {
+    "boilerplate": [],
+    "unwrap_patterns": []
+  },
+  "java": {
+    "boilerplate": [],
+    "unwrap_patterns": [
+      {
+        "type": "test_annotation",
+        "pattern": "^\\s*@Test\\s*$",
+        "end_pattern": "^\\s*@Test\\s*$",
+        "keep_content": false,
+        "description": "Remove @Test annotation"
+      },
+      {
+        "type": "class_single_line",
+        "pattern": "^\\s*public\\s+class\\s+\\w+.*\\{\\s*$",
+        "end_pattern": "^\\s*public\\s+class\\s+\\w+.*\\{\\s*$",
+        "keep_content": false,
+        "description": "Remove public class declaration with opening brace on same line"
+      },
+      {
+        "type": "class_opening",
+        "pattern": "^\\s*public\\s+class\\s+\\w+",
+        "end_pattern": "^\\s*\\{\\s*$",
+        "keep_content": false,
+        "description": "Remove public class declaration and opening brace on separate lines"
+      },
+      {
+        "type": "method_single_line",
+        "pattern": "^\\s*public\\s+void\\s+run\\(\\).*\\{\\s*$",
+        "end_pattern": "^\\s*public\\s+void\\s+run\\(\\).*\\{\\s*$",
+        "keep_content": false,
+        "description": "Remove public void run() with opening brace on same line"
+      },
+      {
+        "type": "method_opening",
+        "pattern": "^\\s*public\\s+void\\s+run\\(\\)",
+        "end_pattern": "^\\s*\\{\\s*$",
+        "keep_content": false,
+        "description": "Remove public void run() declaration and opening brace on separate lines"
+      },
+      {
+        "type": "static_main_single_line",
+        "pattern": "^\\s*public\\s+static\\s+void\\s+main\\(.*\\).*\\{\\s*$",
+        "end_pattern": "^\\s*public\\s+static\\s+void\\s+main\\(.*\\).*\\{\\s*$",
+        "keep_content": false,
+        "description": "Remove public static void main() with opening brace on same line"
+      },
+      {
+        "type": "static_main_opening",
+        "pattern": "^\\s*public\\s+static\\s+void\\s+main\\(.*\\)",
+        "end_pattern": "^\\s*\\{\\s*$",
+        "keep_content": false,
+        "description": "Remove public static void main() declaration and opening brace on separate lines"
+      }
+    ]
+  },
+  "php": {
+    "boilerplate": [],
+    "unwrap_patterns": []
+  },
+  "rust": {
+    "boilerplate": [],
+    "unwrap_patterns": []
+  }
+}
+
diff --git a/build/jupyterize/test_jupyterize.py b/build/jupyterize/test_jupyterize.py
new file mode 100644
index 000000000..041e2270b
--- /dev/null
+++ b/build/jupyterize/test_jupyterize.py
@@ -0,0 +1,841 @@
+#!/usr/bin/env python3
+"""
+Basic tests for jupyterize.py
+
+Run with: python test_jupyterize.py
+"""
+
+import os
+import sys
+import tempfile
+import json
+
+# Add parent directory to path
+sys.path.insert(0, os.path.dirname(__file__))
+
+from jupyterize import jupyterize, detect_language, validate_input, parse_file
+
+
+def test_language_detection():
+    """Test language detection from file extensions."""
+    print("Testing language detection...")
+
+    assert detect_language('example.py') == 'python'
+    assert detect_language('example.js') == 'node.js'
+    assert detect_language('example.go') == 'go'
+    assert detect_language('example.cs') == 'c#'
+    assert detect_language('example.java') == 'java'
+    assert detect_language('example.php') == 'php'
+    assert detect_language('example.rs') == 'rust'
+
+    # Test unsupported extension
+    try:
+        detect_language('example.txt')
+        assert False, "Should have raised ValueError"
+    except ValueError as e:
+        assert "Unsupported file extension" in str(e)
+
+    print("✓ Language detection tests passed")
+
+
+def test_basic_conversion():
+    """Test converting a simple Python file."""
+    print("\nTesting basic conversion...")
+
+    # Create test file
+    test_content = """# EXAMPLE: test
+import redis
+
+# STEP_START connect
+r = redis.Redis()
+# STEP_END
+
+# STEP_START set_get
+r.set('foo', 'bar')
+r.get('foo')
+# STEP_END
+"""
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+        f.write(test_content)
+        test_file = f.name
+
+    try:
+        # Convert
+        output_file = test_file.replace('.py', '.ipynb')
+        result = jupyterize(test_file, output_file, verbose=False)
+
+        # Validate output exists
+        assert os.path.exists(output_file), "Output file not created"
+
+        # Load and validate notebook
+        with open(output_file) as f:
+            nb = json.load(f)
+
+        # Check structure
+        assert 'cells' in nb
+        assert 'metadata' in nb
+        assert nb['nbformat'] == 4
+
+        # Check kernel
+        assert nb['metadata']['kernelspec']['name'] == 'python3'
+        assert nb['metadata']['kernelspec']['display_name'] == 'Python 3'
+
+        # Check cells
+        assert len(nb['cells']) == 3  # Preamble + 2 steps
+        assert all(cell['cell_type'] == 'code' for cell in nb['cells'])
+
+        # Check step metadata
+        assert 'step' not in nb['cells'][0]['metadata']  # Preamble has no step
+        assert nb['cells'][1]['metadata']['step'] == 'connect'
+        assert nb['cells'][2]['metadata']['step'] == 'set_get'
+
+        print("✓ Basic conversion test passed")
+
+    finally:
+        # Cleanup
+        if os.path.exists(test_file):
+            os.unlink(test_file)
+        if os.path.exists(output_file):
+            os.unlink(output_file)
+
+
+def test_hide_remove_blocks():
+    """Test that HIDE blocks are included and REMOVE blocks are excluded."""
+    print("\nTesting HIDE and REMOVE blocks...")
+
+    test_content = """# EXAMPLE: test_markers
+# HIDE_START
+import redis
+r = redis.Redis()
+# HIDE_END
+
+# REMOVE_START
+r.flushdb()  # This should be excluded
+# REMOVE_END
+
+# STEP_START test
+r.set('key', 'value')
+# STEP_END
+"""
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+        f.write(test_content)
+        test_file = f.name
+
+    try:
+        output_file = test_file.replace('.py', '.ipynb')
+        jupyterize(test_file, output_file, verbose=False)
+
+        with open(output_file) as f:
+            nb = json.load(f)
+
+        # Check that HIDE content is included
+        preamble_source = ''.join(nb['cells'][0]['source'])
+        assert 'import redis' in preamble_source
+        assert 'r = redis.Redis()' in preamble_source
+
+        # Check that REMOVE content is excluded
+        all_source = ''.join(''.join(cell['source']) for cell in nb['cells'])
+        assert 'flushdb' not in all_source
+
+        print("✓ HIDE/REMOVE blocks test passed")
+
+    finally:
+        if os.path.exists(test_file):
+            os.unlink(test_file)
+        if os.path.exists(output_file):
+            os.unlink(output_file)
+
+
+def test_javascript_file():
+    """Test converting a JavaScript file."""
+    print("\nTesting JavaScript conversion...")
+
+    test_content = """// EXAMPLE: test_js
+// STEP_START connect
+import { createClient } from 'redis';
+const client = createClient();
+await client.connect();
+// STEP_END
+
+// STEP_START set_get
+await client.set('key', 'value');
+const value = await client.get('key');
+// STEP_END
+"""
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.js', delete=False) as f:
+        f.write(test_content)
+        test_file = f.name
+
+    try:
+        output_file = test_file.replace('.js', '.ipynb')
+        jupyterize(test_file, output_file, verbose=False)
+
+        with open(output_file) as f:
+            nb = json.load(f)
+
+        # Check kernel
+        assert nb['metadata']['kernelspec']['name'] == 'javascript'
+        assert nb['metadata']['kernelspec']['display_name'] == 'JavaScript (Node.js)'
+
+        # Check cells
+        assert len(nb['cells']) == 2  # 2 steps
+
+        print("✓ JavaScript conversion test passed")
+
+    finally:
+        if os.path.exists(test_file):
+            os.unlink(test_file)
+        if os.path.exists(output_file):
+            os.unlink(output_file)
+
+
+def test_marker_format_variations():
+    """Test that markers work with and without space after comment prefix."""
+    print("\nTesting marker format variations...")
+
+    # Test with no space after # (e.g., #EXAMPLE: instead of # EXAMPLE:)
+    test_content = """#EXAMPLE: test_no_space
+import redis
+
+#STEP_START connect
+r = redis.Redis()
+#STEP_END
+"""
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+        f.write(test_content)
+        test_file = f.name
+
+    try:
+        output_file = test_file.replace('.py', '.ipynb')
+        jupyterize(test_file, output_file, verbose=False)
+
+        with open(output_file) as f:
+            nb = json.load(f)
+
+        # Should still parse correctly
+        assert len(nb['cells']) == 2  # Preamble + step
+        assert nb['cells'][1]['metadata']['step'] == 'connect'
+
+        print("✓ Marker format variations test passed")
+
+    finally:
+        if os.path.exists(test_file):
+            os.unlink(test_file)
+        if os.path.exists(output_file):
+            os.unlink(output_file)
+
+
+def test_duplicate_step_names():
+    """Test warning for duplicate step names."""
+    print("\nTesting duplicate step names...")
+
+    test_content = """# EXAMPLE: test_duplicates
+# STEP_START connect
+r = redis.Redis()
+# STEP_END
+
+# STEP_START connect
+# This is a duplicate step name
+r.ping()
+# STEP_END
+"""
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+        f.write(test_content)
+        test_file = f.name
+
+    try:
+        output_file = test_file.replace('.py', '.ipynb')
+        # Should complete but log a warning
+        jupyterize(test_file, output_file, verbose=False)
+
+        with open(output_file) as f:
+            nb = json.load(f)
+
+        # Both steps should be created
+        assert len(nb['cells']) == 2
+        assert nb['cells'][0]['metadata']['step'] == 'connect'
+        assert nb['cells'][1]['metadata']['step'] == 'connect'
+
+        print("✓ Duplicate step names test passed")
+
+    finally:
+        if os.path.exists(test_file):
+            os.unlink(test_file)
+        if os.path.exists(output_file):
+            os.unlink(output_file)
+
+
+def test_no_steps_file():
+    """Test file with no STEP markers (only preamble)."""
+    print("\nTesting file with no steps...")
+
+    test_content = """# EXAMPLE: no_steps
+import redis
+r = redis.Redis()
+r.set('key', 'value')
+"""
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+        f.write(test_content)
+        test_file = f.name
+
+    try:
+        output_file = test_file.replace('.py', '.ipynb')
+        jupyterize(test_file, output_file, verbose=False)
+
+        with open(output_file) as f:
+            nb = json.load(f)
+
+        # Should create single preamble cell
+        assert len(nb['cells']) == 1
+        assert 'step' not in nb['cells'][0]['metadata']
+        assert 'import redis' in ''.join(nb['cells'][0]['source'])
+
+        print("✓ No steps file test passed")
+
+    finally:
+        if os.path.exists(test_file):
+            os.unlink(test_file)
+        if os.path.exists(output_file):
+            os.unlink(output_file)
+
+
+def test_nested_markers():
+    """Test detection of nested markers."""
+    print("\nTesting nested markers...")
+
+    test_content = """# EXAMPLE: nested
+# REMOVE_START
+# REMOVE_START
+# This should trigger a warning
+# REMOVE_END
+# REMOVE_END
+"""
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+        f.write(test_content)
+        test_file = f.name
+
+    try:
+        output_file = test_file.replace('.py', '.ipynb')
+        # Should complete but log warnings
+        jupyterize(test_file, output_file, verbose=False)
+
+        # File should still be created
+        assert os.path.exists(output_file)
+
+        print("✓ Nested markers test passed")
+
+    finally:
+        if os.path.exists(test_file):
+            os.unlink(test_file)
+        if os.path.exists(output_file):
+            os.unlink(output_file)
+
+
+def test_error_handling():
+    """Test error handling for invalid inputs."""
+    print("\nTesting error handling...")
+
+    # Test non-existent file
+    try:
+        jupyterize('nonexistent.py', verbose=False)
+        assert False, "Should have raised FileNotFoundError"
+    except FileNotFoundError:
+        pass
+
+    # Test unsupported extension
+    try:
+        jupyterize('test.txt', verbose=False)
+        assert False, "Should have raised ValueError"
+    except ValueError as e:
+        assert "Unsupported file extension" in str(e)
+
+    # Test missing EXAMPLE marker
+    test_content = """import redis
+r = redis.Redis()
+"""
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+        f.write(test_content)
+        test_file = f.name
+
+    try:
+        try:
+            jupyterize(test_file, verbose=False)
+            assert False, "Should have raised ValueError for missing EXAMPLE marker"
+        except ValueError as e:
+            assert "EXAMPLE" in str(e)
+    finally:
+        if os.path.exists(test_file):
+            os.unlink(test_file)
+
+    print("✓ Error handling tests passed")
+
+
+def test_csharp_boilerplate_injection():
+    """Test that C# files get NuGet directives as first cell."""
+    print("\nTesting C# boilerplate injection...")
+
+    test_content = """// EXAMPLE: test_csharp
+using NRedisStack;
+
+public class TestExample {
+    public void Run() {
+        var muxer = ConnectionMultiplexer.Connect("localhost");
+    }
+}
+"""
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.cs', delete=False) as f:
+        f.write(test_content)
+        test_file = f.name
+
+    try:
+        output_file = test_file.replace('.cs', '.ipynb')
+        jupyterize(test_file, output_file, verbose=False)
+
+        with open(output_file) as f:
+            nb = json.load(f)
+
+        # Should have at least one cell
+        assert len(nb['cells']) >= 1, "Should have at least one cell"
+
+        # First cell should be boilerplate
+        first_cell = nb['cells'][0]
+        first_cell_source = ''.join(first_cell['source'])
+        assert '#r "nuget:' in first_cell_source, \
+            f"First cell should contain NuGet directive, got: {first_cell_source}"
+        assert first_cell['metadata'].get('cell_type') == 'boilerplate', \
+            "First cell should be marked as boilerplate"
+
+        print("✓ C# boilerplate injection test passed")
+
+    finally:
+        if os.path.exists(test_file):
+            os.unlink(test_file)
+        if os.path.exists(output_file):
+            os.unlink(output_file)
+
+
+def test_csharp_unwrapping():
+    """Test that C# class/method wrappers are removed."""
+    print("\nTesting C# unwrapping...")
+
+    test_content = """// EXAMPLE: test_unwrap
+using NRedisStack;
+
+public class TestExample {
+    public void Run() {
+        var muxer = ConnectionMultiplexer.Connect("localhost");
+        var db = muxer.GetDatabase();
+    }
+}
+"""
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.cs', delete=False) as f:
+        f.write(test_content)
+        test_file = f.name
+
+    try:
+        output_file = test_file.replace('.cs', '.ipynb')
+        jupyterize(test_file, output_file, verbose=False)
+
+        with open(output_file) as f:
+            nb = json.load(f)
+
+        # Collect all code from all cells
+        all_code = '\n'.join([
+            ''.join(cell['source'])
+            for cell in nb['cells']
+        ])
+
+        # Should NOT contain class/method declarations
+        assert 'public class TestExample' not in all_code, \
+            "Should not contain class declaration"
+        assert 'public void Run()' not in all_code, \
+            "Should not contain method declaration"
+
+        # Should contain the actual code
+        assert 'var muxer = ConnectionMultiplexer.Connect' in all_code, \
+            "Should contain actual code"
+        assert 'var db = muxer.GetDatabase()' in all_code, \
+            "Should contain actual code"
+
+        print("✓ C# unwrapping test passed")
+
+    finally:
+        if os.path.exists(test_file):
+            os.unlink(test_file)
+        if os.path.exists(output_file):
+            os.unlink(output_file)
+
+
+def test_python_no_boilerplate():
+    """Test that Python files don't get boilerplate (not configured)."""
+    print("\nTesting Python (no boilerplate)...")
+
+    test_content = """# EXAMPLE: test_python
+import redis
+
+r = redis.Redis()
+"""
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+        f.write(test_content)
+        test_file = f.name
+
+    try:
+        output_file = test_file.replace('.py', '.ipynb')
+        jupyterize(test_file, output_file, verbose=False)
+
+        with open(output_file) as f:
+            nb = json.load(f)
+
+        # Should have exactly one cell (no boilerplate)
+        assert len(nb['cells']) == 1, \
+            f"Python should have 1 cell (no boilerplate), got {len(nb['cells'])}"
+
+        # First cell should NOT be boilerplate
+        first_cell = nb['cells'][0]
+        assert first_cell['metadata'].get('cell_type') != 'boilerplate', \
+            "Python should not have boilerplate cell"
+
+        print("✓ Python (no boilerplate) test passed")
+
+    finally:
+        if os.path.exists(test_file):
+            os.unlink(test_file)
+        if os.path.exists(output_file):
+            os.unlink(output_file)
+
+
+def main():
+    """Run all tests."""
+    print("=" * 60)
+    print("Running jupyterize tests")
+    print("=" * 60)
+
+    try:
+        # Core functionality tests
+        test_language_detection()
+        test_basic_conversion()
+        test_hide_remove_blocks()
+        test_javascript_file()
+
+        # Edge case tests
+        test_marker_format_variations()
+        test_duplicate_step_names()
+        test_no_steps_file()
+        test_nested_markers()
+
+        # Error handling tests
+        test_error_handling()
+
+        # Language-specific feature tests (C#)
+        test_csharp_boilerplate_injection()
+        test_csharp_unwrapping()
+        test_python_no_boilerplate()
+
+        # Language-specific feature tests (Java)
+        test_java_unwrapping()
+        test_java_static_main_unwrapping()
+        test_java_real_file()
+
+        # Regression tests
+        test_csharp_for_loop_braces()
+
+        print("\n" + "=" * 60)
+        print("All tests passed! ✓")
+        print("=" * 60)
+        return 0
+
+    except AssertionError as e:
+        print(f"\n✗ Test failed: {e}")
+        return 1
+    except Exception as e:
+        print(f"\n✗ Unexpected error: {e}")
+        import traceback
+        traceback.print_exc()
+        return 1
+
+
+def test_java_unwrapping():
+    """Test that Java class/method wrappers and @Test annotations are removed."""
+    print("\nTesting Java unwrapping...")
+
+    test_content = """// EXAMPLE: test_java_unwrap
+import redis.clients.jedis.UnifiedJedis;
+
+public class TestExample {
+
+    @Test
+    public void run() {
+        UnifiedJedis jedis = new UnifiedJedis("redis://localhost:6379");
+        jedis.set("key", "value");
+        jedis.close();
+    }
+}
+"""
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.java', delete=False) as f:
+        f.write(test_content)
+        test_file = f.name
+
+    try:
+        output_file = test_file.replace('.java', '.ipynb')
+        jupyterize(test_file, output_file, verbose=False)
+
+        with open(output_file) as f:
+            nb = json.load(f)
+
+        # Collect all code from all cells
+        all_code = '\n'.join([
+            ''.join(cell['source'])
+            for cell in nb['cells']
+        ])
+
+        # Should NOT contain class/method declarations or @Test
+        assert 'public class TestExample' not in all_code, \
+            "Should not contain class declaration"
+        assert '@Test' not in all_code, \
+            "Should not contain @Test annotation"
+        assert 'public void run()' not in all_code, \
+            "Should not contain method declaration"
+
+        # Should contain the actual code
+        assert 'UnifiedJedis jedis = new UnifiedJedis' in all_code, \
+            "Should contain actual code"
+        assert 'jedis.set("key", "value")' in all_code, \
+            "Should contain actual code"
+        assert 'jedis.close()' in all_code, \
+            "Should contain actual code"
+
+        print("✓ Java unwrapping test passed")
+
+    finally:
+        if os.path.exists(test_file):
+            os.unlink(test_file)
+        if os.path.exists(output_file):
+            os.unlink(output_file)
+
+
+def test_java_static_main_unwrapping():
+    """Test that Java static main() method wrappers are removed."""
+    print("\nTesting Java static main() unwrapping...")
+
+    test_content = """// EXAMPLE: test_java_main
+import redis.clients.jedis.UnifiedJedis;
+
+public class MainExample {
+    public static void main(String[] args) {
+        UnifiedJedis jedis = new UnifiedJedis("redis://localhost:6379");
+        jedis.ping();
+    }
+}
+"""
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.java', delete=False) as f:
+        f.write(test_content)
+        test_file = f.name
+
+    try:
+        output_file = test_file.replace('.java', '.ipynb')
+        jupyterize(test_file, output_file, verbose=False)
+
+        with open(output_file) as f:
+            nb = json.load(f)
+
+        # Collect all code from all cells
+        all_code = '\n'.join([
+            ''.join(cell['source'])
+            for cell in nb['cells']
+        ])
+
+        # Should NOT contain class/method declarations
+        assert 'public class MainExample' not in all_code, \
+            "Should not contain class declaration"
+        assert 'public static void main' not in all_code, \
+            "Should not contain main method declaration"
+
+        # Should contain the actual code
+        assert 'UnifiedJedis jedis = new UnifiedJedis' in all_code, \
+            "Should contain actual code"
+        assert 'jedis.ping()' in all_code, \
+            "Should contain actual code"
+
+        print("✓ Java static main() unwrapping test passed")
+
+    finally:
+        if os.path.exists(test_file):
+            os.unlink(test_file)
+        if os.path.exists(output_file):
+            os.unlink(output_file)
+
+
+def test_java_real_file():
+    """Test with a real Java file from the repository."""
+    print("\nTesting with real Java file (LandingExample.java)...")
+
+    # Try both relative paths (from build/jupyterize and from repo root)
+    test_file_options = [
+        'local_examples/client-specific/jedis/LandingExample.java',
+        '../../local_examples/client-specific/jedis/LandingExample.java'
+    ]
+
+    test_file = None
+    for option in test_file_options:
+        if os.path.exists(option):
+            test_file = option
+            break
+
+    if not test_file:
+        print("⚠ Skipping test - file not found in any of:", test_file_options)
+        return
+
+    try:
+        output_file = tempfile.mktemp(suffix='.ipynb')
+        jupyterize(test_file, output_file, verbose=False)
+
+        with open(output_file) as f:
+            nb = json.load(f)
+
+        # Collect all code from all cells
+        all_code = '\n'.join([
+            ''.join(cell['source'])
+            for cell in nb['cells']
+        ])
+
+        # Should NOT contain wrappers
+        assert 'public class LandingExample' not in all_code, \
+            "Should not contain class declaration"
+        assert '@Test' not in all_code, \
+            "Should not contain @Test annotation"
+        assert 'public void run()' not in all_code, \
+            "Should not contain method declaration"
+
+        # Should contain actual code
+        assert 'UnifiedJedis jedis' in all_code, \
+            "Should contain actual code"
+        assert 'jedis.set(' in all_code, \
+            "Should contain actual code"
+
+        # Should have multiple cells (one per step)
+        assert len(nb['cells']) >= 4, \
+            f"Should have at least 4 cells, got {len(nb['cells'])}"
+
+        print("✓ Real Java file test passed")
+
+    finally:
+        if os.path.exists(output_file):
+            os.unlink(output_file)
+
+
+
+def test_csharp_for_loop_braces():
+    """Test that for/foreach loop closing braces are preserved (regression test)."""
+    print("\nTesting C# for/foreach loop closing braces...")
+
+    test_content = """// EXAMPLE: test_for_loop
+using System;
+
+public class TestExample {
+    public void Run() {
+        // STEP_START loop_test
+        for (var i = 0; i < 5; i++)
+        {
+            Console.WriteLine(i);
+        }
+
+        foreach (var item in new[] { 1, 2, 3 })
+        {
+            Console.WriteLine(item);
+        }
+        // STEP_END
+        // REMOVE_START
+        Assert.True(true);
+        // REMOVE_END
+    }
+}
+"""
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.cs', delete=False) as f:
+        f.write(test_content)
+        test_file = f.name
+
+    try:
+        output_file = test_file.replace('.cs', '.ipynb')
+        jupyterize(test_file, output_file, verbose=False)
+
+        with open(output_file) as f:
+            nb = json.load(f)
+
+        # Find the loop_test cell
+        loop_cell = None
+        for cell in nb['cells']:
+            if cell.get('metadata', {}).get('step') == 'loop_test':
+                loop_cell = cell
+                break
+
+        assert loop_cell is not None, "loop_test cell not found"
+
+        code = ''.join(loop_cell['source'])
+
+        # Should contain both for and foreach loops
+        assert 'for (var i = 0; i < 5; i++)' in code
+        assert 'foreach (var item in new[] { 1, 2, 3 })' in code
+
+        # Verify the closing braces are in the right places
+        lines = code.split('\n')
+        for_brace_found = False
+        foreach_brace_found = False
+
+        for i, line in enumerate(lines):
+            if 'Console.WriteLine(i)' in line:
+                # Next non-empty line should be closing brace
+                if i + 1 < len(lines) and lines[i + 1].strip() == '}':
+                    for_brace_found = True
+            if 'Console.WriteLine(item)' in line:
+                # Next non-empty line should be closing brace
+                if i + 1 < len(lines) and lines[i + 1].strip() == '}':
+                    foreach_brace_found = True
+
+        assert for_brace_found, "for loop closing brace not found"
+        assert foreach_brace_found, "foreach loop closing brace not found"
+
+        # Verify no class or method wrappers remain
+        assert 'public class TestExample' not in code
+        assert 'public void Run()' not in code
+
+        # Verify no orphaned closing brace cells exist
+        # (cells containing only closing braces should be filtered out)
+        # Count cells - should not have an extra cell with just closing braces
+        # Expected: boilerplate + using statement + loop_test = 3 cells
+        assert len(nb['cells']) == 3, \
+            f"Expected 3 cells, got {len(nb['cells'])}"
+
+        # Verify no cell contains only closing braces
+        for cell in nb['cells']:
+            cell_code = ''.join(cell['source'])
+            stripped = cell_code.strip()
+            # Check if cell is only closing braces
+            if stripped and all(c in '}\n\t ' for c in stripped):
+                assert False, f"Found orphaned closing brace cell: {repr(cell_code)}"
+
+        print("✓ C# for/foreach loop braces test passed")
+
+    finally:
+        if os.path.exists(test_file):
+            os.unlink(test_file)
+        if os.path.exists(output_file):
+            os.unlink(output_file)
+
+
+if __name__ == '__main__':
+    sys.exit(main())
+