diff --git a/README.md b/README.md
index ba10a91..86218d3 100644
--- a/README.md
+++ b/README.md
@@ -3,224 +3,267 @@
 
 <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
 
-**TL;DR**: `%%testcell` prevents your testing cells from affecting the
-global namespace.
+One good thing about working in Jupyter notebooks is that they make it
+easy to quickly test a bit of code by evaluating it in notebook cell.
+But one bad thing is that the *definitions* resulting from that
+evaluation hang around afterwards, when all you wanted was just to test
+that one bit of code.
 
-The Python cell magic `%%testcell` executes a cell without *polluting*
-the notebook’s global namespace. This is useful whenever you want to
-test your code without having any of the local variables escape that
-cell.
+`%%testcell` is a simple simple solution to that problem. It lets you
+execute notebook cells in isolation. Test code, try snippets, and
+experiment freely: no variables, functions, classes, or imports are left
+behind. This helps to keep your namespace clean, so that leftover
+symbols do not confuse later work.
 
-What’s happening under the hood is that your cell code, before being
-executed, is wrapped in a temporary function that will be deleted after
-execution. To give you the feeling of *seamless integration* the last
-statement is optionally returned like it happens in a normal cell.
-
-**WARNING:** this don’t protect you from *the side effects of your code*
-like deleting a file or mutating the state of a global variable.
+**WARNING:** this doesn’t protect you from *the side effects of your
+code* like deleting a file or mutating the state of a global variable.
 
 [![](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/artste/testcell/blob/main/demo/testcell_demo.ipynb)
-
 [![](https://kaggle.com/static/images/open-in-kaggle.svg)](https://www.kaggle.com/artste/introducing-testcell)
+[![](https://modal-cdn.com/open-in-modal.svg)](https://modal.com/notebooks/new/https://github.com/artste/testcell/blob/main/demo/testcell_demo.ipynb)
 
 ## Install
 
+Lightweight and reliable: `%%testcell` depends only on IPython and works
+in all major notebook environments including Jupyter, Colab, Kaggle,
+Modal, Solveit, and the IPython console.
+
 ``` sh
 pip install testcell
 ```
 
-## How to use
+## Quick Start
+
+First import `testcell`:
+
+``` python
+import testcell
+```
 
-just import it with `import testcell` and then use the `%%testcell` cell
-magic.
+Then use it:
 
 ``` python
 %%testcell
-a = "'a' is not polluting global scope"
-a
+temp_var = "This won't pollute namespace"
+temp_var
 ```
 
-    "'a' is not polluting global scope"
+    "This won't pollute namespace"
 
 ``` python
-assert 'a' not in locals()
+# temp_var doesn't exist — it was only defined inside the test cell
+temp_var  # NameError: name 'temp_var' is not defined
 ```
 
-What is happening under the hood is that `%%testcell` wraps your cell’s
-code with a function, execute it and then deletes it. Adding the
-`verbose` keywork will print which code will be executed.
+## How it works
 
-NOTE: The actual cell code is enclosed within `BEGIN` and `END` comment
-blocks for improved readability.
+Import `testcell` and use the `%%testcell` magic at the top of any cell.
+Under the hood, your code is wrapped in a temporary function that
+executes and then deletes itself.
+
+Use `verbose` to see the generated wrapper code:
 
 ``` python
 %%testcell verbose
-a = "'a' is not polluting global scope"
-a
+result = "isolated execution"
+result
 ```
 
-    "'a' is not polluting global scope"
-
-If you’re just interested in seeing what will be executed, but actually
-not executing it, you ca use `dryrun` option:
-
 ``` python
-%%testcell dryrun
-a = "'a' is not polluting global scope"
-a
+### BEGIN
+def _test_cell_():
+    #| echo: false
+    result = "isolated execution"
+    return result # %%testcell
+try:
+    _ = _test_cell_()
+finally:
+    del _test_cell_
+_ # This will be added to global scope
+### END
 ```
 
-If you add a semicolon `;` at the end of your last statement no `return`
-statement is added and nothing is displayed like a normal jupyter cell.
+    'isolated execution'
+
+## Suppressing output
+
+Like normal Jupyter cells, add a semicolon `;` to the last statement to
+suppress display:
 
 ``` python
-%%testcell verbose
-a = "'a' is not polluting global scope"
-a;
+%%testcell
+calculation = 42 * 2
+calculation;
 ```
 
-`testcell` works seamlessly with existing `print` or `display`statements
-on last line:
+No output is displayed, and `calculation` still doesn’t leak to globals.
+
+## Skip execution
+
+Skip cells without deleting code using the `skip` command.
+
+**IMPORTANT**: This is especially useful in notebook environments like
+**Colab, Kaggle, and Modal** where you can’t use Jupyter’s “Raw cell”
+type to disable execution.
 
 ``` python
-%%testcell verbose
-a = "'a' is not polluting global scope"
-print(a)
+%%testcell skip
+raise ValueError('This will not execute')
 ```
 
-    'a' is not polluting global scope
+    <testcell.MessageBox object>
 
-Moreover, thanks to `ast`, it properly deals with complex situations
-like comments on the last line and multi lines statements
+To skip all `%%testcell` cells at once (useful for production runs),
+use: `testcell.global_skip = True`
+
+## Visual marking
+
+Use `banner` to display a colored indicator at the top of cell output,
+making test cells instantly recognizable:
 
 ``` python
-%%testcell verbose
-a = "'a' is not polluting global scope"
-(a,
- True)
-# this is a comment on last line
+%%testcell banner
+"clearly marked"
 ```
 
-    ("'a' is not polluting global scope", True)
+    <testcell.MessageBox object>
+
+    'clearly marked'
+
+**The banner adapts to your environment.** In HTML-based notebooks like
+Jupyter, it displays as a full-width colored box. In console
+environments like IPython, it appears as text with an emoji.
 
-### Skip execution
+Colors and emojis are fully customizable through `testcell.params`.
 
-It is possible to skip a cell execution using `skip` command. This is
-usueful when you want to keep around the code but don’t actually run it.
-It’s also possible to skip **all cells markked with `%%testcell`** using
-the following syntax: `testcell.global_skip=True`.
+**IMPORTANT**: To enable banners for all `%%testcell` cells, use:
+**`testcell.global_use_banner = True`**
 
-        <div style="background-color: #808080; padding: 3px; text-align: center; font-size: 12px; color: white;">
-            This cell has been skipped
-        </div>
-        &#10;
+## Run in complete isolation
 
-### Run in isolation
+`%%testcelln` is a shortcut for `%%testcell noglobals` and executes
+cells with **zero access** to your notebook’s global scope. Only
+Python’s `__builtins__` are available.
 
-`%%testcelln` is a shortcut for `%%testcell noglobals` and executes the
-cell in complete isolation from the global scope. This is very useful
-when you want to ensure that global variables or namespaces are not
-accessible within the cell.
+This is powerful for: - **Detecting hidden dependencies**: catch when
+your code accidentally relies on global variables - **Testing
+portability**: verify functions work standalone - **Clean slate
+execution**: run code exactly as it would in a fresh Python session
 
 ``` python
-aaa = 'global variable'
+my_global = "I'm in the global scope"
 ```
 
 ``` python
 %%testcell
-'aaa' in globals()
+'my_global' in globals()
 ```
 
-    True
-
 ``` python
-%%testcell noglobals
-'aaa' in globals()
+    True # my_global is available
 ```
 
-    False
-
 ``` python
 %%testcelln
-'aaa' in globals()
+'my_global' in globals()
 ```
 
-    False
+``` python
+    False # my_global is NOT available
+```
 
 ``` python
 %%testcelln
 globals().keys()
 ```
 
+``` python
     dict_keys(['__builtins__'])
+```
 
-With `%%testcelln` inside the cell, you’ll be able to access only to
-`__builtins__` (aka: standard python’s functions). **It behaves like a
-notebook-in-notebook**.
-
-``` python
-%%testcell
-def my_function(x):
-    print(aaa) # global variable
-    return x
+## Explicit dependencies
 
-try:
-    my_function(123)
-except Exception as e:
-    print(e)
-```
+The `(inputs)->(outputs)` syntax gives you precise control: you can pass
+any symbol (variables, functions, classes) into the isolated context and
+save only chosen ones back to globals.
 
-    global variable
+This **forces explicit dependency declaration**, giving you full control
+over what enters and exits the cell. It prevents accidental reliance on
+symbols from the main context that would hurt you when exporting the
+code.
 
 ``` python
-%%testcelln
-def my_function(x):
-    print(aaa) # global variable
-    return x
-
-try:
-    my_function(123)
-except Exception as e:
-    print(e)
+data = [1, 2, 3, 4, 5]
 ```
 
-    name 'aaa' is not defined
+``` python
+%%testcelln (data)->(calculate_stats)
+# Only 'data' is available, only 'calculate_stats' is saved
+
+def calculate_stats(values):
+    return {
+        'mean': sum(values) / len(values),
+        'min': min(values),
+        'max': max(values)
+    }
+
+# Test it works
+print(calculate_stats(data))
+```
 
-As you can see from this last example, `%%testcelln` helps you to
-identify that `my_function` refers global variable `aaa`.
+    {'mean': 3.0, 'min': 1, 'max': 5}
 
-**IMPORTANT**: this is *just wrapping your cell* and so it’s still
-running on your main kernel. If you modify variables that has been
-created outside of this cell (aka: if you have side effects) this will
-not protect you.
+`calculate_stats` now **exists in globals**. No test code or
+intermediate variables leaked.
 
 ``` python
-aaa
+calculate_stats([10, 20, 30])
 ```
 
-    'global variable'
+    {'mean': 20.0, 'min': 10, 'max': 30}
 
-``` python
-%%testcell 
-# WARNING: this will alter the state of global variable:
-globals().update({'aaa' : 'modified global variable'});
-```
+## Advanced parsing
+
+Thanks to Python’s `ast` module, `%%testcell` correctly handles complex
+code patterns including comments on the last line and multi-line
+statements:
 
 ``` python
-aaa
+%%testcell verbose
+result = "complex parsing"
+(result,
+ True)
+# comment on last line
 ```
 
-    'modified global variable'
-
 ``` python
-del aaa
+### BEGIN
+def _test_cell_():
+    #| echo: false
+    result = "complex parsing"
+    return (result,
+     True) # %%testcell
+try:
+    _ = _test_cell_()
+finally:
+    del _test_cell_
+_ # This will be added to global scope
+### END
 ```
 
+    ('complex parsing', True)
+
 ## Links:
 
 - PROJECT PAGE: <https://github.com/artste/testcell>
 - DOCUMENTATION: <https://artste.github.io/testcell>
 - PYPI: <https://pypi.org/project/testcell>
+- DETAILED DEMO:
+  <https://github.com/artste/testcell/blob/main/demo/testcell_demo.ipynb>
+- USE CASE ZOO:
+  <https://github.com/artste/testcell/blob/main/demo/testcell_zoo.ipynb>
+- LAUNCHING BLOG: [Introducing
+  `%%testcell`](https://artste.github.io/blog/posts/introducing-testcell)
 - COLAB DEMO:
   [testcell_demo.ipynb](https://colab.research.google.com/github/artste/testcell/blob/main/demo/testcell_demo.ipynb)
 - KAGGLE SAMPLE NOTEBOOK:
diff --git a/demo/testcell_demo.ipynb b/demo/testcell_demo.ipynb
index d34700b..d82ebb1 100644
--- a/demo/testcell_demo.ipynb
+++ b/demo/testcell_demo.ipynb
@@ -20,7 +20,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "a9d36534",
    "metadata": {},
    "outputs": [],
@@ -30,7 +30,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "id": "574fdb14",
    "metadata": {},
    "outputs": [],
@@ -50,7 +50,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "id": "c4de6797",
    "metadata": {},
    "outputs": [],
@@ -65,10 +65,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "id": "545b0118",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__builtin__', '__builtins__', '_ih', '_oh', '_dh', 'In', 'Out', 'get_ipython', 'exit', 'quit', 'open', '_', '__', '___', '__session__', '_i', '_ii', '_iii', '_i1', '_i2', 'testcell', '_i3', 'os', 'sample_variable', 'sample_function', '_i4'])"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "globals().keys()"
    ]
@@ -85,10 +96,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "id": "30027b0f",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"'a' is not polluting global scope\""
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "%%testcell\n",
     "a = \"'a' is not polluting global scope\"\n",
@@ -97,7 +119,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "id": "a135198e",
    "metadata": {},
    "outputs": [],
@@ -108,10 +130,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "id": "3f369a4a",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"'a' is not polluting global scope\""
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "%%testcell\n",
     "a = \"'a' is not polluting global scope\"; a # it works as inline too even if there is a comment"
@@ -119,7 +152,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "id": "2ea4f41f",
    "metadata": {},
    "outputs": [],
@@ -138,10 +171,79 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "id": "1e70eb60",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<svg style=\"width:200; display:block; margin:auto\"  xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"100%\" height=\"100%\" viewBox=\"0 0 300 300\">\n",
+       "\t    \n",
+       "\t      <title>SVG Logo</title>\n",
+       "\t      <desc>Designed for the SVG Logo Contest in 2006 by Harvey Rayner, and adopted by W3C in 2009. It is available under the Creative Commons license for those who have an SVG product or who are using SVG on their site.</desc>\n",
+       "\t     \n",
+       "\t       <metadata id=\"license\">\n",
+       "\t         <rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:cc=\"http://web.resource.org/cc/\">\n",
+       "\t           <cc:Work rdf:about=\"\">\n",
+       "\t             <dc:title>SVG Logo</dc:title>\n",
+       "\t             <dc:date>14-08-2009</dc:date>\n",
+       "\t             <dc:creator>\n",
+       "\t               <cc:Agent><dc:title>W3C</dc:title></cc:Agent>\n",
+       "\t               <cc:Agent><dc:title>Harvey Rayner, designer</dc:title></cc:Agent>\n",
+       "\t             </dc:creator>\n",
+       "\t             <dc:description>See document description</dc:description>\n",
+       "\t             <cc:license rdf:resource=\"http://creativecommons.org/licenses/by-nc-sa/2.5/\"/>\n",
+       "\t             <dc:format>image/svg+xml</dc:format>\n",
+       "\t             <dc:type rdf:resource=\"http://purl.org/dc/dcmitype/StillImage\"/>\n",
+       "\t           </cc:Work>\n",
+       "\t           <cc:License rdf:about=\"http://creativecommons.org/licenses/by-nc-sa/2.5/\">\n",
+       "\t             <cc:permits rdf:resource=\"http://web.resource.org/cc/Reproduction\"/>\n",
+       "\t             <cc:permits rdf:resource=\"http://web.resource.org/cc/Distribution\"/>\n",
+       "\t             <cc:requires rdf:resource=\"http://web.resource.org/cc/Notice\"/>\n",
+       "\t             <cc:requires rdf:resource=\"http://web.resource.org/cc/Attribution\"/>\n",
+       "\t             <cc:prohibits rdf:resource=\"http://web.resource.org/cc/CommercialUse\"/>\n",
+       "\t             <cc:permits rdf:resource=\"http://web.resource.org/cc/DerivativeWorks\"/>\n",
+       "\t             <cc:requires rdf:resource=\"http://web.resource.org/cc/ShareAlike\"/>\n",
+       "\t           </cc:License>\n",
+       "\t         </rdf:RDF>\n",
+       "\t       </metadata>\n",
+       "\t       \n",
+       "\t    \n",
+       "\t       <defs>\n",
+       "\t         <g id=\"SVG\" fill=\"#ffffff\" transform=\"scale(2) translate(20,79)\">\n",
+       "\t            <path id=\"S\" d=\"M 5.482,31.319 C2.163,28.001 0.109,23.419 0.109,18.358 C0.109,8.232 8.322,0.024 18.443,0.024 C28.569,0.024 36.782,8.232 36.782,18.358 L26.042,18.358 C26.042,14.164 22.638,10.765 18.443,10.765 C14.249,10.765 10.850,14.164 10.850,18.358 C10.850,20.453 11.701,22.351 13.070,23.721 L13.075,23.721 C14.450,25.101 15.595,25.500 18.443,25.952 L18.443,25.952 C23.509,26.479 28.091,28.006 31.409,31.324 L31.409,31.324 C34.728,34.643 36.782,39.225 36.782,44.286 C36.782,54.412 28.569,62.625 18.443,62.625 C8.322,62.625 0.109,54.412 0.109,44.286 L10.850,44.286 C10.850,48.480 14.249,51.884 18.443,51.884 C22.638,51.884 26.042,48.480 26.042,44.286 C26.042,42.191 25.191,40.298 23.821,38.923 L23.816,38.923 C22.441,37.548 20.468,37.074 18.443,36.697 L18.443,36.692 C13.533,35.939 8.800,34.638 5.482,31.319 L5.482,31.319 L5.482,31.319 Z\"/>\n",
+       "\t    \n",
+       "\t            <path id=\"V\" d=\"M 73.452,0.024 L60.482,62.625 L49.742,62.625 L36.782,0.024 L47.522,0.024 L55.122,36.687 L62.712,0.024 L73.452,0.024 Z\"/>\n",
+       "\t    \n",
+       "\t            <path id=\"G\" d=\"M 91.792,25.952 L110.126,25.952 L110.126,44.286 L110.131,44.286 C110.131,54.413 101.918,62.626 91.792,62.626 C81.665,62.626 73.458,54.413 73.458,44.286 L73.458,44.286 L73.458,18.359 L73.453,18.359 C73.453,8.233 81.665,0.025 91.792,0.025 C101.913,0.025 110.126,8.233 110.126,18.359 L99.385,18.359 C99.385,14.169 95.981,10.765 91.792,10.765 C87.597,10.765 84.198,14.169 84.198,18.359 L84.198,44.286 L84.198,44.286 C84.198,48.481 87.597,51.880 91.792,51.880 C95.981,51.880 99.380,48.481 99.385,44.291 L99.385,44.286 L99.385,36.698 L91.792,36.698 L91.792,25.952 L91.792,25.952 Z\"/>\n",
+       "\t          </g>\n",
+       "\t       </defs>\n",
+       "\t    \n",
+       "\t       <path id=\"base\" fill=\"#000\" d=\"M8.5,150 H291.5 V250 C291.5,273.5 273.5,291.5 250,291.5 H50 C26.5,291.5 8.5,273.5 8.5,250 Z\"/>\n",
+       "\t       <g stroke-width=\"38.0086\" stroke=\"#000\">\n",
+       "\t         <g id=\"svgstar\" transform=\"translate(150, 150)\">\n",
+       "\t           <path id=\"svgbar\" fill=\"#ffb13b\" d=\"M-84.1487,-15.8513 a22.4171,22.4171 0 1 0 0,31.7026 h168.2974 a22.4171,22.4171 0 1 0 0,-31.7026 Z\"/>\n",
+       "\t           <use xlink:href=\"#svgbar\" transform=\"rotate(45)\"/>\n",
+       "\t           <use xlink:href=\"#svgbar\" transform=\"rotate(90)\"/>\n",
+       "\t           <use xlink:href=\"#svgbar\" transform=\"rotate(135)\"/>\n",
+       "\t         </g>\n",
+       "\t       </g>\n",
+       "\t       <use xlink:href=\"#svgstar\"/>\n",
+       "\t       <use xlink:href=\"#base\" opacity=\"0.85\"/>\n",
+       "\t       <use xlink:href=\"#SVG\"/>\n",
+       "\t    \n",
+       "\t    </svg>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "%%testcell\n",
     "from IPython.display import SVG,HTML\n",
@@ -225,10 +327,53 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "id": "9e576724",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "```python\n",
+       "### BEGIN\n",
+       "def _test_cell_():\n",
+       "\tb = 123\n",
+       "\treturn b # %%testcell\n",
+       "try:\n",
+       "\t_ = _test_cell_()\n",
+       "finally:\n",
+       "\tdel _test_cell_\n",
+       "_ # This will be added to global scope\n",
+       "### END\n",
+       "```"
+      ],
+      "text/plain": [
+       "### BEGIN\n",
+       "def _test_cell_():\n",
+       "\tb = 123\n",
+       "\treturn b # %%testcell\n",
+       "try:\n",
+       "\t_ = _test_cell_()\n",
+       "finally:\n",
+       "\tdel _test_cell_\n",
+       "_ # This will be added to global scope\n",
+       "### END"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "123"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "%%testcell verbose\n",
     "b = 123\n",
@@ -247,10 +392,43 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "id": "3065d361",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "```python\n",
+       "### BEGIN\n",
+       "def _test_cell_():\n",
+       "\tb = 123\n",
+       "\treturn print('You should not see this message on the output') # %%testcell\n",
+       "try:\n",
+       "\t_ = _test_cell_()\n",
+       "finally:\n",
+       "\tdel _test_cell_\n",
+       "if _ is not None: display(_)\n",
+       "### END\n",
+       "```"
+      ],
+      "text/plain": [
+       "### BEGIN\n",
+       "def _test_cell_():\n",
+       "\tb = 123\n",
+       "\treturn print('You should not see this message on the output') # %%testcell\n",
+       "try:\n",
+       "\t_ = _test_cell_()\n",
+       "finally:\n",
+       "\tdel _test_cell_\n",
+       "if _ is not None: display(_)\n",
+       "### END"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "%%testcell dryrun\n",
     "b = 123\n",
@@ -270,10 +448,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "id": "19ab37cc",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "123"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "%%testcell noreturn\n",
     "b = 123\n",
@@ -293,10 +481,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "id": "b0a2abfd",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "dict_keys(['__builtins__'])\n"
+     ]
+    }
+   ],
    "source": [
     "%%testcelln\n",
     "assert list(globals().keys()) == ['__builtins__']\n",
@@ -316,10 +512,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "id": "c8fe2586-4dec-48f3-a486-5e7b6d46d10b",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "            <div style=\"background-color: #808080; padding: 3px; text-align: center; font-size: 12px; color: white;\">\n",
+       "              This cell has been skipped\n",
+       "            </div>\n",
+       "            "
+      ],
+      "text/plain": [
+       "ℹ️ This cell has been skipped"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "%%testcell skip\n",
     "raise ValueError('This should not be executed')"
@@ -337,10 +550,37 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "id": "cedecb62-35d2-4cdd-ac28-2473e0093d8e",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "            <div style=\"background-color: yellow; padding: 3px; text-align: center; font-size: 12px; color: black;\">\n",
+       "              testcell\n",
+       "            </div>\n",
+       "            "
+      ],
+      "text/plain": [
+       "🟡 testcell"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'This is a banner for regular %%testcell cell'"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "%%testcell banner\n",
     "'This is a banner for regular %%testcell cell'"
@@ -348,15 +588,210 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 16,
    "id": "c9584772-e407-415e-a6bc-24ee44c66455",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "            <div style=\"background-color: green; padding: 3px; text-align: center; font-size: 12px; color: white;\">\n",
+       "              testcell noglobals\n",
+       "            </div>\n",
+       "            "
+      ],
+      "text/plain": [
+       "🟢 testcell noglobals"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'This is a banner for %%testcell noglobals cell'"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "%%testcelln banner\n",
     "'This is a banner for %%testcell noglobals cell'"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "451f0524-3e5e-4881-85b2-bdd7ea48c2a3",
+   "metadata": {},
+   "source": [
+    "### `%%testcelln` (sample_variable)->(new_func)\n",
+    "This is the most advanced use case and let you execute code on an isolated context, but adding access to `sample_variable` and returning to the global context the function `new_func`.\n",
+    "Additionaly we're using the \"debug\" option that shows step by step what's happening under the hood."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "24c7c686-7a9a-458c-b486-ba353c3c4b52",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "```python\n",
+       "### BEGIN\n",
+       "def _test_cell_():\n",
+       "\tglobal new_func\n",
+       "\tdef new_func(): return sample_variable\n",
+       "\t\n",
+       "\treturn new_func() # %%testcell\n",
+       "try:\n",
+       "\t_ = _test_cell_()\n",
+       "finally:\n",
+       "\tdel _test_cell_\n",
+       "if _ is not None: display(_)\n",
+       "### END\n",
+       "```"
+      ],
+      "text/plain": [
+       "### BEGIN\n",
+       "def _test_cell_():\n",
+       "\tglobal new_func\n",
+       "\tdef new_func(): return sample_variable\n",
+       "\t\n",
+       "\treturn new_func() # %%testcell\n",
+       "try:\n",
+       "\t_ = _test_cell_()\n",
+       "finally:\n",
+       "\tdel _test_cell_\n",
+       "if _ is not None: display(_)\n",
+       "### END"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'this is a sample variable'"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "```python\n",
+       "### GLOBALS UPDATE CODE:\n",
+       "global new_func; new_func=locals()[\"new_func\"]\n",
+       "###\n",
+       "```"
+      ],
+      "text/plain": [
+       "### GLOBALS UPDATE CODE:\n",
+       "global new_func; new_func=locals()[\"new_func\"]\n",
+       "###"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcelln (sample_variable)->(new_func) debug\n",
+    "def new_func(): return sample_variable\n",
+    "\n",
+    "new_func()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "12387ed0-89c9-45dd-9d2f-ab7c0673ceef",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert new_func()==sample_variable\n",
+    "del new_func #cleanup state"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "08394121-0f6e-4b73-b9a6-4e6a43dc4859",
+   "metadata": {},
+   "source": [
+    "This is an exmaple of **input only**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "634d2155-545b-4aae-957e-11c3491d5e6d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'this is a sample variable'"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcelln (sample_variable)\n",
+    "def new_func(): return sample_variable\n",
+    "new_func()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "581c1dc9-db12-42b6-a6ca-233cda556e1b",
+   "metadata": {},
+   "source": [
+    "This is an exmaple of **output only**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "fb8ba9cb-6082-4071-89e5-9d8dbdf118fb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "123"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcelln ->(new_func)\n",
+    "def new_func(): return 123\n",
+    "new_func()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "ddc07336-e208-440f-969d-b88468a3da48",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert new_func()==123\n",
+    "del new_func #cleanup state"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "05290ea3",
diff --git a/demo/testcell_zoo.ipynb b/demo/testcell_zoo.ipynb
new file mode 100644
index 0000000..6f2f7e4
--- /dev/null
+++ b/demo/testcell_zoo.ipynb
@@ -0,0 +1,2539 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "f5b071d3-d836-4128-9596-ce3f2f4d21c9",
+   "metadata": {},
+   "source": [
+    "# Testcell Zoo"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "40eb3af8-1dec-428d-8e22-40374f63245a",
+   "metadata": {},
+   "source": [
+    "## Introduction\n",
+    "\n",
+    "This notebook demonstrates practical use cases for `%%testcell`. Each example is self-contained and can be run independently after loading the fixtures."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d75a2d0b",
+   "metadata": {},
+   "source": [
+    "### install\n",
+    "\n",
+    "First of all, install and import `testcell`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "92505d86-5f42-4f5f-8d3c-6008b6b113be",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install testcell"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "db3d55aa-237c-4033-8ace-621202fcfa4d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Install dependecies used in this notebook\n",
+    "!pip install numpy pandas matplotlib"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "574fdb14",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import testcell"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a5cbdc78-47e9-470c-9187-f00c9c229527",
+   "metadata": {},
+   "source": [
+    "### Fixtures\n",
+    "\n",
+    "Common objects used throughout the examples:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "9818ce17-f533-4fa3-a442-68fcf4908b2c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Simple variable\n",
+    "global_variable = \"I'm a global variable\"\n",
+    "\n",
+    "# Simple list\n",
+    "global_list = [1, 2, 3, 5, 7, 11, 13]\n",
+    "\n",
+    "# Simple function\n",
+    "def global_function(n):\n",
+    "    return n*2\n",
+    "\n",
+    "# Simple class\n",
+    "class GlobalClass:\n",
+    "    def one(self):\n",
+    "        return 37\n",
+    "    \n",
+    "    def two(self):\n",
+    "        return \"method of global class\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "181a3890-f9df-44b7-afcb-db906d85d800",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Fixing random state for reproducibility\n",
+    "import numpy as np\n",
+    "np.random.seed(123)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "574ff0f3-d605-4c0d-8ed4-463e0adfc3d3",
+   "metadata": {},
+   "source": [
+    "## Documentation\n",
+    "\n",
+    "Individual options and their behavior:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9579085-fa36-4f1d-a4b8-91aa4c50a209",
+   "metadata": {},
+   "source": [
+    "### option: `verbose`\n",
+    "Shows the generated wrapper function before execution."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "1849ad22-85f6-4f7d-9ab2-25c847bfcf1f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "```python\n",
+       "### BEGIN\n",
+       "def _test_cell_():\n",
+       "\t\n",
+       "\treturn global_function(3) * 2 # %%testcell\n",
+       "try:\n",
+       "\t_ = _test_cell_()\n",
+       "finally:\n",
+       "\tdel _test_cell_\n",
+       "_ # This will be added to global scope\n",
+       "### END\n",
+       "```"
+      ],
+      "text/plain": [
+       "### BEGIN\n",
+       "def _test_cell_():\n",
+       "\t\n",
+       "\treturn global_function(3) * 2 # %%testcell\n",
+       "try:\n",
+       "\t_ = _test_cell_()\n",
+       "finally:\n",
+       "\tdel _test_cell_\n",
+       "_ # This will be added to global scope\n",
+       "### END"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "12"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%%testcell verbose\n",
+    "global_function(3) * 2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "49c32487-bbf7-4d6a-bc57-50597809b3fe",
+   "metadata": {},
+   "source": [
+    "### option `dryrun`\n",
+    "Shows the wrapper code without executing it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e96b57e1-31f9-4af6-b673-fc8387e32007",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "```python\n",
+       "### BEGIN\n",
+       "def _test_cell_():\n",
+       "\t\n",
+       "\treturn global_function(3) * 2 # %%testcell\n",
+       "try:\n",
+       "\t_ = _test_cell_()\n",
+       "finally:\n",
+       "\tdel _test_cell_\n",
+       "if _ is not None: display(_)\n",
+       "### END\n",
+       "```"
+      ],
+      "text/plain": [
+       "### BEGIN\n",
+       "def _test_cell_():\n",
+       "\t\n",
+       "\treturn global_function(3) * 2 # %%testcell\n",
+       "try:\n",
+       "\t_ = _test_cell_()\n",
+       "finally:\n",
+       "\tdel _test_cell_\n",
+       "if _ is not None: display(_)\n",
+       "### END"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcell dryrun\n",
+    "global_function(3) * 2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bad62496-6d10-4627-86af-2abc3ba9a752",
+   "metadata": {},
+   "source": [
+    "### option `skip`\n",
+    "Skips cell execution entirely."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "ff0bb19d-d263-46da-9176-d2abee049f8f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "            <div style=\"background-color: #808080; padding: 3px; text-align: center; font-size: 12px; color: white;\">\n",
+       "              This cell has been skipped\n",
+       "            </div>\n",
+       "            "
+      ],
+      "text/plain": [
+       "ℹ️ This cell has been skipped"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcell skip\n",
+    "raise ValueError(\"This won't execute\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "762017da-2a77-458c-bb94-843239baafaf",
+   "metadata": {},
+   "source": [
+    "### option `banner`\n",
+    "Displays a visual marker at the top of output."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "9357a4b7-d2fa-455e-b0dd-61efc76c5b4f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "            <div style=\"background-color: yellow; padding: 3px; text-align: center; font-size: 12px; color: black;\">\n",
+       "              testcell\n",
+       "            </div>\n",
+       "            "
+      ],
+      "text/plain": [
+       "🟡 testcell"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "6"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%%testcell banner\n",
+    "global_function(3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "2927380d-4dc1-487f-90d4-ae0ebdff18dc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "            <div style=\"background-color: green; padding: 3px; text-align: center; font-size: 12px; color: white;\">\n",
+       "              testcell noglobals\n",
+       "            </div>\n",
+       "            "
+      ],
+      "text/plain": [
+       "🟢 testcell noglobals"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "This is running in an isolated environment\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%testcelln banner\n",
+    "print('This is running in an isolated environment')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "96abea99-be60-4244-a00c-2fccd28cbd65",
+   "metadata": {},
+   "source": [
+    "### option `noglobals` (or `%%testcelln`)\n",
+    "Executes with zero access to notebook globals - only `__builtins__` available."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "c8f4ee3c-750c-4e84-a321-2a5be1d976a1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "global_function not available here\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%testcelln\n",
+    "try:\n",
+    "    global_function(3)  # This will fail\n",
+    "except NameError:\n",
+    "    print('global_function not available here')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "fd7f6e61-b159-4d81-9b89-910fbae42c34",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "global_function not available here\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%testcell noglobals\n",
+    "try:\n",
+    "    global_function(3)  # This will fail\n",
+    "except NameError:\n",
+    "    print('global_function not available here')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1963ed9c-026d-437e-9ca6-763a2c637e9a",
+   "metadata": {},
+   "source": [
+    "### option `(inputs)` syntax\n",
+    "Explicitly control what enters in the isolated context."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "48412b54-b2ce-4cdb-8a2e-7dac4a3a2d98",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[2, 4, 6, 10, 14, 22, 26]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcelln (global_list)\n",
+    "[x * 2 for x in global_list]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "bffb1ef7-4c40-4d82-8b37-e5d72e93079e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "37"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcelln (GlobalClass)\n",
+    "GlobalClass().one()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "77e834b2-6c40-4b61-8a43-3734656e861f",
+   "metadata": {},
+   "source": [
+    "### option `(inputs)->(outputs)` syntax\n",
+    "Explicitly control what enters and exits the isolated context."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "008e7a4c-86c9-46da-8ddc-cfef3e482fc2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[2, 4, 6, 10, 14, 22, 26]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcelln (global_list)->(double_list)\n",
+    "double_list = [x * 2 for x in global_list]\n",
+    "double_list"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "e0426272-2f12-4658-ad08-eba79b63cc43",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2, 4, 6, 10, 14, 22, 26]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(double_list) # double_list now exists in the global namespace\n",
+    "del double_list # cleanin it up"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e3b33f77-cdb7-4ccb-9896-edb5070726ea",
+   "metadata": {},
+   "source": [
+    "### option `debug`\n",
+    "Shows wrapper code AND globals update operations."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "4773e185-9605-4567-bab4-1abc910f353d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "```python\n",
+       "### BEGIN\n",
+       "def _test_cell_():\n",
+       "\tglobal new_var\n",
+       "\tnew_var = global_variable.upper()\n",
+       "\treturn new_var # %%testcell\n",
+       "try:\n",
+       "\t_ = _test_cell_()\n",
+       "finally:\n",
+       "\tdel _test_cell_\n",
+       "if _ is not None: display(_)\n",
+       "### END\n",
+       "```"
+      ],
+      "text/plain": [
+       "### BEGIN\n",
+       "def _test_cell_():\n",
+       "\tglobal new_var\n",
+       "\tnew_var = global_variable.upper()\n",
+       "\treturn new_var # %%testcell\n",
+       "try:\n",
+       "\t_ = _test_cell_()\n",
+       "finally:\n",
+       "\tdel _test_cell_\n",
+       "if _ is not None: display(_)\n",
+       "### END"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\"I'M A GLOBAL VARIABLE\""
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "```python\n",
+       "### GLOBALS UPDATE CODE:\n",
+       "global new_var; new_var=locals()[\"new_var\"]\n",
+       "###\n",
+       "```"
+      ],
+      "text/plain": [
+       "### GLOBALS UPDATE CODE:\n",
+       "global new_var; new_var=locals()[\"new_var\"]\n",
+       "###"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcelln (global_variable)->(new_var) debug\n",
+    "new_var = global_variable.upper()\n",
+    "new_var"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "94a81e1e-9bc7-46a9-b5c9-3c67327daced",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "del new_var"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dc485ee8-b811-497e-9baf-7627d4a1f3b1",
+   "metadata": {},
+   "source": [
+    "## Use Case Scenarios"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "23d09c78-8ff9-449d-b846-2128fc5b526c",
+   "metadata": {},
+   "source": [
+    "### Basic Isolation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4e1bfff7-a9d6-4b12-b6c0-7ad0adf1a502",
+   "metadata": {},
+   "source": [
+    "#### Testing without pollution\n",
+    "\n",
+    "Test a function with various inputs without cluttering globals with test values."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "1c6d0120-9c43-427b-b26d-f21f74138fb5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Results: [2, 10, 20, 200]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "np.float64(58.0)"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%%testcell\n",
+    "import numpy as np\n",
+    "\n",
+    "# Test global_function with different inputs\n",
+    "test_cases = [1, 5, 10, 100]\n",
+    "results = [global_function(x) for x in test_cases]\n",
+    "print(f\"Results: {results}\")\n",
+    "np.mean(results)  # test_cases and results don't leak to globals"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "06669ac7-51fa-4187-b607-b23436058a87",
+   "metadata": {},
+   "source": [
+    "#### Quick code prototyping\n",
+    "\n",
+    "Experiment with different approaches without commitment."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "a465106a-18f1-49b2-a012-a20f13504437",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Approach 1: [2.0, 3.3333333333333335, 5.0, 7.666666666666667, 10.333333333333334]\n",
+      "Approach 2: [2.0, 3.3333333333333335, 5.0, 7.666666666666667, 10.333333333333334]\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%testcell\n",
+    "import pandas as pd\n",
+    "\n",
+    "# Trying different ways to process global_list\n",
+    "approach_1 = pd.Series(global_list).rolling(3).mean().dropna()\n",
+    "approach_2 = [sum(global_list[i:i+3])/3 for i in range(len(global_list)-2)]\n",
+    "print(f\"Approach 1: {approach_1.tolist()}\")\n",
+    "print(f\"Approach 2: {approach_2}\")\n",
+    "# Nothing saved - decide later which approach to keep"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4227e7c2-8abb-43fd-8a91-724267bd18b7",
+   "metadata": {},
+   "source": [
+    "#### Stack Overflow snippet testing\n",
+    "\n",
+    "Test SO answers in isolation to catch hidden dependencies."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "e3887d3e-b47d-4abb-9a06-86a7b399f8cd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcelln\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "# SO snippet for quick visualization\n",
+    "x = np.linspace(0, 10, 100)\n",
+    "y = np.sin(x)\n",
+    "plt.plot(x, y)\n",
+    "plt.title(\"Testing SO snippet\")\n",
+    "plt.show()  # Completely isolated - no globals needed or leaked"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dc06aadf-a3e3-4036-8fbd-8b02ab7e92c2",
+   "metadata": {},
+   "source": [
+    "#### Safe LLM suggested code experimentation\n",
+    "\n",
+    "Try code from ChatGPT/Claude in complete isolation - verify it works standalone."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "cd8d15ba-ee02-43a8-90ca-7bd1a28c2ca2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>A</th>\n",
+       "      <th>B</th>\n",
+       "      <th>ratio</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>count</th>\n",
+       "      <td>7.000000</td>\n",
+       "      <td>7.000000</td>\n",
+       "      <td>7.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>mean</th>\n",
+       "      <td>6.000000</td>\n",
+       "      <td>54.000000</td>\n",
+       "      <td>6.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>std</th>\n",
+       "      <td>4.582576</td>\n",
+       "      <td>65.719099</td>\n",
+       "      <td>4.582576</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>min</th>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>25%</th>\n",
+       "      <td>2.500000</td>\n",
+       "      <td>6.500000</td>\n",
+       "      <td>2.500000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>50%</th>\n",
+       "      <td>5.000000</td>\n",
+       "      <td>25.000000</td>\n",
+       "      <td>5.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>75%</th>\n",
+       "      <td>9.000000</td>\n",
+       "      <td>85.000000</td>\n",
+       "      <td>9.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>max</th>\n",
+       "      <td>13.000000</td>\n",
+       "      <td>169.000000</td>\n",
+       "      <td>13.000000</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "               A           B      ratio\n",
+       "count   7.000000    7.000000   7.000000\n",
+       "mean    6.000000   54.000000   6.000000\n",
+       "std     4.582576   65.719099   4.582576\n",
+       "min     1.000000    1.000000   1.000000\n",
+       "25%     2.500000    6.500000   2.500000\n",
+       "50%     5.000000   25.000000   5.000000\n",
+       "75%     9.000000   85.000000   9.000000\n",
+       "max    13.000000  169.000000  13.000000"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcelln (global_list)\n",
+    "import pandas as pd\n",
+    "\n",
+    "# Suppose an LLM suggested this snippet\n",
+    "data = {'A': global_list, 'B': [x**2 for x in global_list]}\n",
+    "df = pd.DataFrame(data)\n",
+    "df['ratio'] = df['B'] / df['A']\n",
+    "df.describe()  # Runs in isolation, only global_list was passed in"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "5f8576c0-9a7a-40bb-8b4a-647ff205aa1e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert 'df' not in locals() # Ensure df is not in the local scope\n",
+    "assert 'df' not in globals() # Ensure df is not in the global scope"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "84c2b7eb-919d-4a92-a567-71243841a53e",
+   "metadata": {},
+   "source": [
+    "### Visualization & Analysis"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dc9b82fc-c4e2-432d-a59e-33fc5794a99b",
+   "metadata": {},
+   "source": [
+    "#### Matplotlib without clutter\n",
+    "\n",
+    "Create plots without importing `plt`, `fig`, or `ax` into globals. For example, this could be a code snippet from the documentation that you want to understand and experiment with."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "f3e757d9-b253-43d9-bf67-85e051b5faba",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 900x400 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcelln\n",
+    "# FROM: https://matplotlib.org/stable/gallery/statistics/hexbin_demo.html#sphx-glr-gallery-statistics-hexbin-demo-py\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "n = 100_000\n",
+    "x = np.random.default_rng(seed=19680801).standard_normal(n) # inline seeded generator\n",
+    "y = 2.0 + 3.0 * x + 4.0 * np.random.standard_normal(n)\n",
+    "xlim = x.min(), x.max()\n",
+    "ylim = y.min(), y.max()\n",
+    "\n",
+    "fig, (ax0, ax1) = plt.subplots(ncols=2, sharey=True, figsize=(9, 4))\n",
+    "\n",
+    "hb = ax0.hexbin(x, y, gridsize=50, cmap='inferno')\n",
+    "ax0.set(xlim=xlim, ylim=ylim)\n",
+    "ax0.set_title(\"Hexagon binning\")\n",
+    "cb = fig.colorbar(hb, ax=ax0, label='counts')\n",
+    "\n",
+    "hb = ax1.hexbin(x, y, gridsize=50, bins='log', cmap='inferno')\n",
+    "ax1.set(xlim=xlim, ylim=ylim)\n",
+    "ax1.set_title(\"With a log color scale\")\n",
+    "cb = fig.colorbar(hb, ax=ax1, label='counts')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "5da54b5c-6341-403d-9001-83565b50a187",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Note that matplotlib has not been importad in global scope\n",
+    "assert 'matplotlib' not in globals()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "014bd19e-7d52-48a1-afe0-34cee14cbf0a",
+   "metadata": {},
+   "source": [
+    "#### Data transformation testing\n",
+    "\n",
+    "Test complex pandas pipelines without keeping intermediate results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "b6dca02a-7f88-4de1-9488-708166b04daf",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "      <th>squared</th>\n",
+       "      <th>log</th>\n",
+       "      <th>normalized</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>-1.091089</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0.693147</td>\n",
+       "      <td>-0.872872</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>3</td>\n",
+       "      <td>9</td>\n",
+       "      <td>1.098612</td>\n",
+       "      <td>-0.654654</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>5</td>\n",
+       "      <td>25</td>\n",
+       "      <td>1.609438</td>\n",
+       "      <td>-0.218218</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>7</td>\n",
+       "      <td>49</td>\n",
+       "      <td>1.945910</td>\n",
+       "      <td>0.218218</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>11</td>\n",
+       "      <td>121</td>\n",
+       "      <td>2.397895</td>\n",
+       "      <td>1.091089</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>13</td>\n",
+       "      <td>169</td>\n",
+       "      <td>2.564949</td>\n",
+       "      <td>1.527525</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   values  squared       log  normalized\n",
+       "0       1        1  0.000000   -1.091089\n",
+       "1       2        4  0.693147   -0.872872\n",
+       "2       3        9  1.098612   -0.654654\n",
+       "3       5       25  1.609438   -0.218218\n",
+       "4       7       49  1.945910    0.218218\n",
+       "5      11      121  2.397895    1.091089\n",
+       "6      13      169  2.564949    1.527525"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%%testcell\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "\n",
+    "df = pd.DataFrame({'values': global_list})\n",
+    "transformed = (df\n",
+    "    .assign(squared=lambda x: x['values']**2)\n",
+    "    .assign(log=lambda x: np.log(x['values']))\n",
+    "    .assign(normalized=lambda x: (x['values'] - x['values'].mean()) / x['values'].std())\n",
+    ")\n",
+    "transformed  # df and transformed don't leak"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e2ec685e-3140-4802-82e3-fd793b731068",
+   "metadata": {},
+   "source": [
+    "#### Statistical analysis sandbox\n",
+    "\n",
+    "Run complex analyses without polluting namespace."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "06d2a37f-e1ec-485f-b925-9f89551faf1c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "mean      49.542272\n",
+       "median    49.691380\n",
+       "std        8.812565\n",
+       "q25       43.523162\n",
+       "q75       55.185949\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%%testcell\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "\n",
+    "data = np.random.normal(loc=50, scale=10, size=100)\n",
+    "stats = {\n",
+    "    'mean': np.mean(data),\n",
+    "    'median': np.median(data),\n",
+    "    'std': np.std(data),\n",
+    "    'q25': np.percentile(data, 25),\n",
+    "    'q75': np.percentile(data, 75)\n",
+    "}\n",
+    "pd.Series(stats)  # data and stats don't persist"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b3cae828-2abb-48a1-ae87-08afe2bb1cd8",
+   "metadata": {},
+   "source": [
+    "### Skip feature"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7a7431c0-4644-4cdc-91ae-05c78d0e0700",
+   "metadata": {},
+   "source": [
+    "#### A/B testing approaches\n",
+    "\n",
+    "Toggle between different implementations without deleting code."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "b2df1a3d-c95a-46d5-a108-5420f5466ae0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Approach A result: 6.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%testcell\n",
+    "import numpy as np\n",
+    "# Approach A: using numpy\n",
+    "result = np.array(global_list).mean()\n",
+    "print(f\"Approach A result: {result}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "968a250d-6d4c-4fbe-9d9e-ebed1f63d81b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "            <div style=\"background-color: #808080; padding: 3px; text-align: center; font-size: 12px; color: white;\">\n",
+       "              This cell has been skipped\n",
+       "            </div>\n",
+       "            "
+      ],
+      "text/plain": [
+       "ℹ️ This cell has been skipped"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcell skip\n",
+    "# Approach B: pure python (currently disabled)\n",
+    "result = sum(global_list) / len(global_list)\n",
+    "print(f\"Approach B result: {result}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "70808ee6-6100-44b8-acbd-77bddcde12b7",
+   "metadata": {},
+   "source": [
+    "#### Disable expensive operations\n",
+    "\n",
+    "Skip time-consuming cells during development iteration."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "268381af-c478-43e4-b527-2e3a31f4f948",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "            <div style=\"background-color: #808080; padding: 3px; text-align: center; font-size: 12px; color: white;\">\n",
+       "              This cell has been skipped\n",
+       "            </div>\n",
+       "            "
+      ],
+      "text/plain": [
+       "ℹ️ This cell has been skipped"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcell skip\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Expensive simulation - skip while working on other parts\n",
+    "data = np.random.randn(1000000)\n",
+    "for i in range(100):\n",
+    "    data = data * np.random.random() + np.random.randn(1000000)\n",
+    "plt.hist(data, bins=50)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "78b07769-b64e-4d3b-8ffa-27d05ef7742f",
+   "metadata": {},
+   "source": [
+    "#### Conditional cell execution with global_skip\n",
+    "\n",
+    "Disable all testcell cells at once for production runs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "a80e5967-dd0f-44a6-a868-8b1ab065436f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Enable this to skip all %%testcell cells\n",
+    "testcell.global_skip = True"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "5c15ee09-4f83-41c9-bfe4-07ed8d9857c6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "            <div style=\"background-color: #808080; padding: 3px; text-align: center; font-size: 12px; color: white;\">\n",
+       "              This cell has been skipped\n",
+       "            </div>\n",
+       "            "
+      ],
+      "text/plain": [
+       "ℹ️ This cell has been skipped"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcell\n",
+    "print(\"This won't execute when global_skip is True\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "4cf1f579-9766-4c95-9b03-c8b10b4774c6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Reset for other examples\n",
+    "testcell.global_skip = False"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9d08b709-bfa4-4d0d-9ad0-7117b0b0a0aa",
+   "metadata": {},
+   "source": [
+    "#### Iterative development in Colab/Modal\n",
+    "\n",
+    "Skip cells in platforms without native \"Raw cell\" type."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "27c3c0f1-74bd-47b5-8ec6-a0afc62f9180",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "            <div style=\"background-color: #808080; padding: 3px; text-align: center; font-size: 12px; color: white;\">\n",
+       "              This cell has been skipped\n",
+       "            </div>\n",
+       "            "
+      ],
+      "text/plain": [
+       "ℹ️ This cell has been skipped"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcell skip\n",
+    "# Work-in-progress code that's not ready yet\n",
+    "# Colab/Kaggle/Modal don't have \"Raw\" cells, so this is perfect\n",
+    "import pandas as pd\n",
+    "experimental_feature = pd.DataFrame(global_list)\n",
+    "# TODO: finish this later"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "baa724bf-83c4-4be2-a4ce-93a4d6a64e93",
+   "metadata": {},
+   "source": [
+    "### Complete isolation (noglobals/testcelln)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "624c22eb-1c65-4400-b362-4471aa80330b",
+   "metadata": {},
+   "source": [
+    "#### Pure function testing\n",
+    "\n",
+    "Verify functions work without global dependencies."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "9a0acc06-e74e-433c-a0c3-2c7c68c15ff5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'mean': np.float64(3.0),\n",
+       " 'std': np.float64(1.4142135623730951),\n",
+       " 'sum': np.int64(15)}"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcelln\n",
+    "import numpy as np\n",
+    "\n",
+    "# Define and test a pure function\n",
+    "def calculate_stats(values):\n",
+    "    return {\n",
+    "        'mean': np.mean(values),\n",
+    "        'std': np.std(values),\n",
+    "        'sum': np.sum(values)\n",
+    "    }\n",
+    "\n",
+    "# Test with local data\n",
+    "calculate_stats([1, 2, 3, 4, 5])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0e3c4c1c-970d-4ca0-aed1-c61bde89041a",
+   "metadata": {},
+   "source": [
+    "#### Detect hidden dependencies\n",
+    "\n",
+    "Catch when code accidentally relies on globals."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "8fd0452a-e7b9-442a-a6f8-3c2f144b5970",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Caught dependency: name 'global_list' is not defined\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%testcelln\n",
+    "import pandas as pd\n",
+    "\n",
+    "# This will fail - exposes dependency on global_list\n",
+    "def process_data():\n",
+    "    return pd.Series(global_list).describe()\n",
+    "\n",
+    "try:\n",
+    "    process_data()\n",
+    "except NameError as e:\n",
+    "    print(f\"Caught dependency: {e}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eb90f0ac-75d4-48f6-a5cc-5bf563d4360b",
+   "metadata": {},
+   "source": [
+    "#### Clean slate execution\n",
+    "\n",
+    "Run code with only `__builtins__` available."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "08766664-4eed-400f-814c-15595676dc7e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Only available: ['__builtins__']\n",
+      "Can use built-ins like sum: 6\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%testcelln\n",
+    "# Verify truly isolated environment\n",
+    "available = list(globals().keys())\n",
+    "print(f\"Only available: {available}\")\n",
+    "print(f\"Can use built-ins like sum: {sum([1,2,3])}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3b98ae8c-239e-4e50-8ce3-ca54b772a1bb",
+   "metadata": {},
+   "source": [
+    "#### Reproducibility verification\n",
+    "\n",
+    "Ensure code doesn't rely on notebook state."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "453047fa-960a-43ff-a0e3-ea5933c0ca2e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "      <th>normalized</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1</td>\n",
+       "      <td>-1.091089</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2</td>\n",
+       "      <td>-0.872872</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>3</td>\n",
+       "      <td>-0.654654</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>5</td>\n",
+       "      <td>-0.218218</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>7</td>\n",
+       "      <td>0.218218</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>11</td>\n",
+       "      <td>1.091089</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>13</td>\n",
+       "      <td>1.527525</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   values  normalized\n",
+       "0       1   -1.091089\n",
+       "1       2   -0.872872\n",
+       "2       3   -0.654654\n",
+       "3       5   -0.218218\n",
+       "4       7    0.218218\n",
+       "5      11    1.091089\n",
+       "6      13    1.527525"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcelln\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "\n",
+    "# Self-contained analysis - no hidden dependencies\n",
+    "data = [1, 2, 3, 5, 7, 11, 13]\n",
+    "df = pd.DataFrame({'values': data})\n",
+    "df['normalized'] = (df['values'] - df['values'].mean()) / df['values'].std()\n",
+    "df"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b79652f7-9bd2-424f-87a8-a5ec3dd7965f",
+   "metadata": {},
+   "source": [
+    "### (input)->(output) syntax"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b2284441-3b68-4c61-a5c2-fcd7f40340e2",
+   "metadata": {},
+   "source": [
+    "#### Controlled input to isolated cell\n",
+    "\n",
+    "Pass specific variables to noglobals context without full access."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "664f9d8f-a295-4773-80d0-8a705bac4127",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "np.float64(54.0)"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcelln (global_list)\n",
+    "import numpy as np\n",
+    "\n",
+    "# Only global_list is available\n",
+    "squared = [x**2 for x in global_list]\n",
+    "np.mean(squared)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "847d6fc1-a04e-401b-89e1-9b84d41c62b5",
+   "metadata": {},
+   "source": [
+    "#### Safe experimentation with expensive state\n",
+    "\n",
+    "Protect important objects while experimenting - pass them in, don't leak experiments out."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "23600f42-530a-4a89-aed1-896201154723",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "expensive_model = np.random.randn(1000, 1000)  # Pretend this took hours to compute"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "714abe60-955c-4c3f-8e61-d6ef86ec54eb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test prediction mean: -0.6658779858466216\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%testcelln (expensive_model)\n",
+    "import numpy as np\n",
+    "\n",
+    "# Experiment safely - expensive_model is read-only here\n",
+    "test_input = np.random.randn(1000)\n",
+    "prediction = expensive_model @ test_input\n",
+    "temp_analysis = prediction.mean()\n",
+    "print(f\"Test prediction mean: {temp_analysis}\")\n",
+    "# temp_analysis and test_input don't leak"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "1b3ef669-2843-4f30-939c-e7cde0aa1ba2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Cleanup\n",
+    "del expensive_model "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0753b824-78a1-4b18-bf26-a14ac675372b",
+   "metadata": {},
+   "source": [
+    "#### Selective output saving\n",
+    "\n",
+    "Save only specific results back to globals."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "id": "b3317933-4eef-4ae2-99e8-3d2b833c2798",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "      <th>squared</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>3</td>\n",
+       "      <td>9</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>5</td>\n",
+       "      <td>25</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>7</td>\n",
+       "      <td>49</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>11</td>\n",
+       "      <td>121</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>13</td>\n",
+       "      <td>169</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   values  squared\n",
+       "0       1        1\n",
+       "1       2        4\n",
+       "2       3        9\n",
+       "3       5       25\n",
+       "4       7       49\n",
+       "5      11      121\n",
+       "6      13      169"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcelln (global_list)->(final_result, summary_stats)\n",
+    "import pandas as pd\n",
+    "\n",
+    "# Complex processing with many intermediate variables\n",
+    "df = pd.DataFrame({'values': global_list})\n",
+    "df['squared'] = df['values'] ** 2\n",
+    "df['cubed'] = df['values'] ** 3\n",
+    "intermediate = df.describe()\n",
+    "\n",
+    "# Only these two are saved to globals\n",
+    "final_result = df[['values', 'squared']].copy()\n",
+    "summary_stats = {'mean': df['values'].mean(), 'max': df['values'].max()}\n",
+    "\n",
+    "final_result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "id": "0edab722-39b9-45d8-a8cc-f428153d0617",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "final_result exists: True\n",
+      "summary_stats exists: True\n",
+      "df exists: False\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Verify only selected outputs exist\n",
+    "print(f\"final_result exists: {'final_result' in globals()}\")\n",
+    "print(f\"summary_stats exists: {'summary_stats' in globals()}\")\n",
+    "print(f\"df exists: {'df' in globals()}\")  # Should be False\n",
+    "\n",
+    "# Cleanup\n",
+    "del final_result, summary_stats"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8424c0c5-7e6e-4102-a9dc-6dec90af9caf",
+   "metadata": {},
+   "source": [
+    "### Advanced scenarios"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "769b2fef-43b1-42e0-abe8-a8f11a02fce4",
+   "metadata": {},
+   "source": [
+    "#### Benchmark alternatives without variable collision\n",
+    "\n",
+    "Compare implementations safely - variables from different approaches don't collide, ensuring fair comparison."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "a12daff1-fbac-4fcc-b084-1eb6165e8b8c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Approach 1 result: 10.242640687119284\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%testcell\n",
+    "import numpy as np\n",
+    "\n",
+    "# Approach 1: using numpy operations\n",
+    "data = np.array(global_list)\n",
+    "result = data.mean() + data.std()\n",
+    "print(f\"Approach 1 result: {result}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "id": "fd32369b-8b31-4ee8-a4c7-ccfec19a59c9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Approach 2 result: 10.582575694955839\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%testcell\n",
+    "import numpy as np\n",
+    "\n",
+    "# Approach 2: slightly different calculation\n",
+    "# 'data' and 'result' from previous cell don't interfere\n",
+    "data = np.array(global_list)\n",
+    "result = np.mean(data) + np.std(data, ddof=1)  # Using sample std\n",
+    "print(f\"Approach 2 result: {result}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "83df0f97-6ecd-4588-bd18-cd506f2b1367",
+   "metadata": {},
+   "source": [
+    "#### Complex fixture extraction with complete isolation\n",
+    "\n",
+    "Test in complete isolation, but extract test results to main context for later use."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "id": "92f7f66f-36b0-4058-b62a-d80b17265823",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "```python\n",
+       "### BEGIN\n",
+       "def _test_cell_():\n",
+       "\tglobal test_suite\n",
+       "\timport pandas as pd\n",
+       "\timport numpy as np\n",
+       "\t\n",
+       "\t# Create test fixtures in isolation - no access to any globals\n",
+       "\ttest_data = pd.DataFrame({\n",
+       "\t    'values': [1, 2, 3, 5, 7, 11, 13],\n",
+       "\t    'doubled': [2, 4, 6, 10, 14, 22, 26]\n",
+       "\t})\n",
+       "\t\n",
+       "\ttest_suite = {\n",
+       "\t    'data': test_data,\n",
+       "\t    'validators': [lambda x: x > 0, lambda x: x < 100],\n",
+       "\t    'summary': test_data.describe().to_dict()\n",
+       "\t}\n",
+       "\t\n",
+       "\treturn test_suite['data'].head() # %%testcell\n",
+       "try:\n",
+       "\t_ = _test_cell_()\n",
+       "finally:\n",
+       "\tdel _test_cell_\n",
+       "if _ is not None: display(_)\n",
+       "### END\n",
+       "```"
+      ],
+      "text/plain": [
+       "### BEGIN\n",
+       "def _test_cell_():\n",
+       "\tglobal test_suite\n",
+       "\timport pandas as pd\n",
+       "\timport numpy as np\n",
+       "\t\n",
+       "\t# Create test fixtures in isolation - no access to any globals\n",
+       "\ttest_data = pd.DataFrame({\n",
+       "\t    'values': [1, 2, 3, 5, 7, 11, 13],\n",
+       "\t    'doubled': [2, 4, 6, 10, 14, 22, 26]\n",
+       "\t})\n",
+       "\t\n",
+       "\ttest_suite = {\n",
+       "\t    'data': test_data,\n",
+       "\t    'validators': [lambda x: x > 0, lambda x: x < 100],\n",
+       "\t    'summary': test_data.describe().to_dict()\n",
+       "\t}\n",
+       "\t\n",
+       "\treturn test_suite['data'].head() # %%testcell\n",
+       "try:\n",
+       "\t_ = _test_cell_()\n",
+       "finally:\n",
+       "\tdel _test_cell_\n",
+       "if _ is not None: display(_)\n",
+       "### END"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "      <th>doubled</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>3</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>5</td>\n",
+       "      <td>10</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>7</td>\n",
+       "      <td>14</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   values  doubled\n",
+       "0       1        2\n",
+       "1       2        4\n",
+       "2       3        6\n",
+       "3       5       10\n",
+       "4       7       14"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "```python\n",
+       "### GLOBALS UPDATE CODE:\n",
+       "global test_suite; test_suite=locals()[\"test_suite\"]\n",
+       "###\n",
+       "```"
+      ],
+      "text/plain": [
+       "### GLOBALS UPDATE CODE:\n",
+       "global test_suite; test_suite=locals()[\"test_suite\"]\n",
+       "###"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcelln ->(test_suite) debug\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "\n",
+    "# Create test fixtures in isolation - no access to any globals\n",
+    "test_data = pd.DataFrame({\n",
+    "    'values': [1, 2, 3, 5, 7, 11, 13],\n",
+    "    'doubled': [2, 4, 6, 10, 14, 22, 26]\n",
+    "})\n",
+    "\n",
+    "test_suite = {\n",
+    "    'data': test_data,\n",
+    "    'validators': [lambda x: x > 0, lambda x: x < 100],\n",
+    "    'summary': test_data.describe().to_dict()\n",
+    "}\n",
+    "\n",
+    "test_suite['data'].head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "id": "d8113ab2-096a-4c18-a814-a6cdd6b5f6b4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test suite keys: dict_keys(['data', 'validators', 'summary'])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# test_suite now available in main context\n",
+    "print(f\"Test suite keys: {test_suite.keys()}\")\n",
+    "del test_suite  # Cleanup"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "37d85e36-ead8-40b2-bfe2-2b4ec0edcc72",
+   "metadata": {},
+   "source": [
+    "#### Pipeline validation during refactoring\n",
+    "\n",
+    "Test two pipeline versions produce identical results - crucial when refactoring to ensure behavior doesn't change."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "id": "88ec22c2-27db-4f7b-be45-4218465f68c0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "      <th>doubled</th>\n",
+       "      <th>normalized</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1</td>\n",
+       "      <td>2</td>\n",
+       "      <td>-1.091089</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2</td>\n",
+       "      <td>4</td>\n",
+       "      <td>-0.872872</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>3</td>\n",
+       "      <td>6</td>\n",
+       "      <td>-0.654654</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>5</td>\n",
+       "      <td>10</td>\n",
+       "      <td>-0.218218</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>7</td>\n",
+       "      <td>14</td>\n",
+       "      <td>0.218218</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>11</td>\n",
+       "      <td>22</td>\n",
+       "      <td>1.091089</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>13</td>\n",
+       "      <td>26</td>\n",
+       "      <td>1.527525</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   values  doubled  normalized\n",
+       "0       1        2   -1.091089\n",
+       "1       2        4   -0.872872\n",
+       "2       3        6   -0.654654\n",
+       "3       5       10   -0.218218\n",
+       "4       7       14    0.218218\n",
+       "5      11       22    1.091089\n",
+       "6      13       26    1.527525"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcelln (global_list)->(pipeline_v1)\n",
+    "import pandas as pd\n",
+    "\n",
+    "def pipeline_v1(data):\n",
+    "    df = pd.DataFrame({'values': data})\n",
+    "    df['doubled'] = df['values'] * 2\n",
+    "    df['normalized'] = (df['doubled'] - df['doubled'].mean()) / df['doubled'].std()\n",
+    "    return df\n",
+    "\n",
+    "pipeline_v1(global_list)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "id": "c60e5102-e24b-4ff8-b90f-6710b744d967",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>values</th>\n",
+       "      <th>doubled</th>\n",
+       "      <th>normalized</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1</td>\n",
+       "      <td>2</td>\n",
+       "      <td>-1.178511</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2</td>\n",
+       "      <td>4</td>\n",
+       "      <td>-0.942809</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>3</td>\n",
+       "      <td>6</td>\n",
+       "      <td>-0.707107</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>5</td>\n",
+       "      <td>10</td>\n",
+       "      <td>-0.235702</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>7</td>\n",
+       "      <td>14</td>\n",
+       "      <td>0.235702</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>11</td>\n",
+       "      <td>22</td>\n",
+       "      <td>1.178511</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>13</td>\n",
+       "      <td>26</td>\n",
+       "      <td>1.649916</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   values  doubled  normalized\n",
+       "0       1        2   -1.178511\n",
+       "1       2        4   -0.942809\n",
+       "2       3        6   -0.707107\n",
+       "3       5       10   -0.235702\n",
+       "4       7       14    0.235702\n",
+       "5      11       22    1.178511\n",
+       "6      13       26    1.649916"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcelln (global_list)->(pipeline_v2)\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "\n",
+    "def pipeline_v2(data):\n",
+    "    # Refactored version - more efficient\n",
+    "    df = pd.DataFrame({'values': data})\n",
+    "    doubled = np.array(df['values']) * 2\n",
+    "    df['doubled'] = doubled\n",
+    "    df['normalized'] = (doubled - doubled.mean()) / doubled.std()\n",
+    "    return df\n",
+    "\n",
+    "pipeline_v2(global_list)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "id": "ddfa72c5-f094-4013-b3dc-8efe26ead105",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<style type=\"text/css\">\n",
+       "#T_stable_row0_col2 {\n",
+       "  background-color: #fde725;\n",
+       "  color: #000000;\n",
+       "}\n",
+       "#T_stable_row1_col2 {\n",
+       "  background-color: #c8e020;\n",
+       "  color: #000000;\n",
+       "}\n",
+       "#T_stable_row2_col2 {\n",
+       "  background-color: #90d743;\n",
+       "  color: #000000;\n",
+       "}\n",
+       "#T_stable_row3_col2 {\n",
+       "  background-color: #35b779;\n",
+       "  color: #f1f1f1;\n",
+       "}\n",
+       "#T_stable_row4_col2 {\n",
+       "  background-color: #21918c;\n",
+       "  color: #f1f1f1;\n",
+       "}\n",
+       "#T_stable_row5_col2 {\n",
+       "  background-color: #443983;\n",
+       "  color: #f1f1f1;\n",
+       "}\n",
+       "#T_stable_row6_col2 {\n",
+       "  background-color: #440154;\n",
+       "  color: #f1f1f1;\n",
+       "}\n",
+       "</style>\n",
+       "<table id=\"T_stable\">\n",
+       "  <thead>\n",
+       "    <tr>\n",
+       "      <th class=\"blank level0\" >&nbsp;</th>\n",
+       "      <th id=\"T_stable_level0_col0\" class=\"col_heading level0 col0\" >values</th>\n",
+       "      <th id=\"T_stable_level0_col1\" class=\"col_heading level0 col1\" >doubled</th>\n",
+       "      <th id=\"T_stable_level0_col2\" class=\"col_heading level0 col2\" >normalized</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th id=\"T_stable_level0_row0\" class=\"row_heading level0 row0\" >0</th>\n",
+       "      <td id=\"T_stable_row0_col0\" class=\"data row0 col0\" >0</td>\n",
+       "      <td id=\"T_stable_row0_col1\" class=\"data row0 col1\" >0</td>\n",
+       "      <td id=\"T_stable_row0_col2\" class=\"data row0 col2\" >0.087422</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th id=\"T_stable_level0_row1\" class=\"row_heading level0 row1\" >1</th>\n",
+       "      <td id=\"T_stable_row1_col0\" class=\"data row1 col0\" >0</td>\n",
+       "      <td id=\"T_stable_row1_col1\" class=\"data row1 col1\" >0</td>\n",
+       "      <td id=\"T_stable_row1_col2\" class=\"data row1 col2\" >0.069937</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th id=\"T_stable_level0_row2\" class=\"row_heading level0 row2\" >2</th>\n",
+       "      <td id=\"T_stable_row2_col0\" class=\"data row2 col0\" >0</td>\n",
+       "      <td id=\"T_stable_row2_col1\" class=\"data row2 col1\" >0</td>\n",
+       "      <td id=\"T_stable_row2_col2\" class=\"data row2 col2\" >0.052453</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th id=\"T_stable_level0_row3\" class=\"row_heading level0 row3\" >3</th>\n",
+       "      <td id=\"T_stable_row3_col0\" class=\"data row3 col0\" >0</td>\n",
+       "      <td id=\"T_stable_row3_col1\" class=\"data row3 col1\" >0</td>\n",
+       "      <td id=\"T_stable_row3_col2\" class=\"data row3 col2\" >0.017484</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th id=\"T_stable_level0_row4\" class=\"row_heading level0 row4\" >4</th>\n",
+       "      <td id=\"T_stable_row4_col0\" class=\"data row4 col0\" >0</td>\n",
+       "      <td id=\"T_stable_row4_col1\" class=\"data row4 col1\" >0</td>\n",
+       "      <td id=\"T_stable_row4_col2\" class=\"data row4 col2\" >-0.017484</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th id=\"T_stable_level0_row5\" class=\"row_heading level0 row5\" >5</th>\n",
+       "      <td id=\"T_stable_row5_col0\" class=\"data row5 col0\" >0</td>\n",
+       "      <td id=\"T_stable_row5_col1\" class=\"data row5 col1\" >0</td>\n",
+       "      <td id=\"T_stable_row5_col2\" class=\"data row5 col2\" >-0.087422</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th id=\"T_stable_level0_row6\" class=\"row_heading level0 row6\" >6</th>\n",
+       "      <td id=\"T_stable_row6_col0\" class=\"data row6 col0\" >0</td>\n",
+       "      <td id=\"T_stable_row6_col1\" class=\"data row6 col1\" >0</td>\n",
+       "      <td id=\"T_stable_row6_col2\" class=\"data row6 col2\" >-0.122391</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "execution_count": 51,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%%testcell\n",
+    "# Inspect differences\n",
+    "from IPython.display import HTML\n",
+    "import pandas as pd\n",
+    "styler = (pipeline_v1(global_list) - pipeline_v2(global_list)).style.background_gradient(cmap='viridis', subset=['normalized'])\n",
+    "\n",
+    "# Hack to avoid randomness in colored table html generation\n",
+    "styler.set_uuid(\"stable\")  # <- freeze the table id\n",
+    "HTML(styler.to_html())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "id": "b43e6de4-c4ba-4b31-ac5b-7f118fcf45b4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Cleanup\n",
+    "del pipeline_v1, pipeline_v2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a1afcc17-689d-4661-8645-cd8bb7a0665c",
+   "metadata": {},
+   "source": [
+    "#### Debugging global pollution and dependencies\n",
+    "\n",
+    "Same code behaves differently with testcell vs testcelln - exposes hidden dependency on global scope."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "id": "a1a7be2c-3dec-4f73-88dd-24f5a9f0ba9d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set up a variable that code might accidentally depend on\n",
+    "scale_factor = 10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "id": "1722d9ea-9b49-4101-ab9b-477594ddf00d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "np.float64(60.0)"
+      ]
+     },
+     "execution_count": 54,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%%testcell\n",
+    "import numpy as np\n",
+    "\n",
+    "# This works - has access to scale_factor\n",
+    "data = np.array(global_list) * scale_factor\n",
+    "data.mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "id": "3f6bdfc1-87b8-4f72-960a-657a487290ec",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "❌ Hidden dependency detected: name 'scale_factor' is not defined\n",
+      "Code relies on 'scale_factor' from global scope!\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%testcelln\n",
+    "import numpy as np\n",
+    "\n",
+    "# This fails - exposes the hidden dependency\n",
+    "try:\n",
+    "    data = np.array([1,2,3,5,7,11,13]) * scale_factor\n",
+    "    data.mean()\n",
+    "except NameError as e:\n",
+    "    print(f\"❌ Hidden dependency detected: {e}\")\n",
+    "    print(\"Code relies on 'scale_factor' from global scope!\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "id": "b446b0cf-4670-4089-be96-cfd2073bdd18",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Cleanup\n",
+    "del scale_factor"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/nbs/01a_arguments.ipynb b/nbs/01a_arguments.ipynb
new file mode 100644
index 0000000..73c6702
--- /dev/null
+++ b/nbs/01a_arguments.ipynb
@@ -0,0 +1,371 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "40730acc",
+   "metadata": {},
+   "source": [
+    "# arguments"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1e4407a1",
+   "metadata": {},
+   "source": [
+    "This module is meant to add all the support functions for *arguments* and *inout* parsing."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c927be30",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| default_exp inout"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ea55fe32",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from fastcore.test import *"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "81f5dc52",
+   "metadata": {},
+   "source": [
+    "## Find support function"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1e602995",
+   "metadata": {},
+   "source": [
+    "`optional_find` let you search a string in forward or reverse order using one or more *templates* (aka: reference sub-strings).\n",
+    "\n",
+    "It returns the *first* occurrence that is the leftmost in forward direction and rightmost in reverse direction.\n",
+    "The occurrence returned is a tuple `(position,template)` where:\n",
+    "+ `position`: is the position inside the string.\n",
+    "+ `template`: is the copy of the template found. We need this to understand where that string finishes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "95d0ba51",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "def optional_find(x,cc,reverse=False):\n",
+    "    if isinstance(cc,str): cc = [cc] # listify\n",
+    "    t = [(x.rfind(c) if reverse else x.find(c),c) for c in cc]\n",
+    "    t = [(f,c) for f,c in t if f != -1]\n",
+    "    if len(t)==0: return None\n",
+    "    return max(t) if reverse else min(t)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "efb977d3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Single\n",
+    "test_eq( optional_find('abc','a')[0] , 0)\n",
+    "test_eq( optional_find('abc','c')[0] , 2)\n",
+    "test_eq( optional_find('abc','bc')[0] , 1)\n",
+    "test_eq( optional_find('abc','z'), None)\n",
+    "test_eq( optional_find('abcdefghiab','a',reverse=True)[0] , 9)\n",
+    "test_eq( optional_find('abc','bc',reverse=True)[0] , 1)\n",
+    "\n",
+    "# Multi\n",
+    "test_eq( optional_find('abcdefghiab',['aa','fg','ia'],reverse=False)[0] , 5)\n",
+    "test_eq( optional_find('abcdefghiab',['aa','fg','ia'],reverse=True)[0] , 8)\n",
+    "test_eq( optional_find('abcdefghiab',['aa','ia','fg'],reverse=True)[0] , 8)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b547c7cb",
+   "metadata": {},
+   "source": [
+    "## Character level utility"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8a6e5b12",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "def count_char(x,c):\n",
+    "    # Count how many times c appears in x\n",
+    "    return sum(map(lambda y: y==c,x))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f6954a2d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_eq( count_char('abacda','a') , 3 )\n",
+    "test_eq( count_char('abacda','b') , 1 )\n",
+    "test_eq( count_char('abacda','z') , 0 )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e5f25890",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "def count_delta(x,a='(',b=')'):\n",
+    "    # Return the difference between the count of \"a\" and \"b\".\n",
+    "    return count_char(x,a) - count_char(x,b)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fd0e9679",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_eq(count_delta('asd(asd)'),0)\n",
+    "test_eq(count_delta('asd(asd'),1)\n",
+    "test_eq(count_delta('asd(a(sd'),2)\n",
+    "test_eq(count_delta('asd(a(sd)))'),-1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d77e6418",
+   "metadata": {},
+   "source": [
+    "## String split utility\n",
+    "\n",
+    "This is just a bit of syntactic sugar"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "49ec1d10",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "def split_and_strip(x,splitter):\n",
+    "    t = [t.strip() for t in x.split(splitter)]\n",
+    "    if t==['']: return []\n",
+    "    return t"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ad718a5c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_eq(split_and_strip('a,b,c',','),['a','b','c'])\n",
+    "test_eq(split_and_strip(' a, b,c ',','),['a','b','c'])\n",
+    "test_eq(split_and_strip('',','),[])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "704acae9",
+   "metadata": {},
+   "source": [
+    "## Inout util\n",
+    "\n",
+    "`inout` is the *name* of the portion of the complete arguments string that refers to input and output parameters.\n",
+    "\n",
+    "For example in this magick line: `%%testcell noglobals (aaa,bbb) ->(ccc)` \n",
+    "+ *raw_arguments*: `noglobals `\n",
+    "+ *inout*: `(aaa,bbb) ->(ccc)`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c2463950",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "def process_inout(x,splitter='->'):\n",
+    "    if x is None: return None\n",
+    "    t = split_and_strip(x,splitter)\n",
+    "    for v,c,n in zip(t,map(count_delta,t),map(lambda s: count_char(s,'('),t)): \n",
+    "        if n>1: raise ValueError(f'Too much parenthesis on \"{v}\"')\n",
+    "        if c>0: raise ValueError(f'Missing closing parenthesis on \"{v}\"')\n",
+    "    t = [x[1:-1] for x in t]\n",
+    "    if len(t)==0: raise ValueError('No groups available')\n",
+    "    if len(t)>2: raise ValueError(f'You should have only one \"{splitter}\" symbol')\n",
+    "    if len(t)==1: return split_and_strip(t[0],','),[]\n",
+    "    if len(t)==2: return split_and_strip(t[0],','),split_and_strip(t[1],',')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "277e15f2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_eq(process_inout(None,splitter='->'),None)\n",
+    "\n",
+    "test_eq(process_inout('(a,b,cc)->(d,ee)',splitter='->'),(['a','b','cc'],['d','ee']))\n",
+    "test_eq(process_inout(' (a,b,cc)  -> (d,ee) ',splitter='->'),(['a','b','cc'],['d','ee']))\n",
+    "test_eq(process_inout(' (a,b,cc)  -> () ',splitter='->'),(['a','b','cc'],[]))\n",
+    "test_eq(process_inout(' (a,b,cc)  ',splitter='->'),(['a','b','cc'],[]))\n",
+    "test_eq(process_inout('()->(a,b,cc)  ',splitter='->'),([],['a','b','cc']))\n",
+    "test_eq(process_inout('->(a,b,cc)  ',splitter='->'),([],['a','b','cc']))\n",
+    "\n",
+    "test_fail(lambda: process_inout('(a,b,cc)(d,ee)'), contains='Too much parenthesis')\n",
+    "test_fail(lambda: process_inout('(a,b,cc) (d,ee)'), contains='Too much parenthesis')\n",
+    "test_fail(lambda: process_inout('(a,b,cc) (->d,ee)'), contains='Too much parenthesis')\n",
+    "test_fail(lambda: process_inout('(a,b,cc->)(d,ee)'), contains='Missing closing parenthesis')\n",
+    "test_fail(lambda: process_inout('(a,b,cc) - > (d,ee)'), contains='Too much parenthesis')\n",
+    "test_fail(lambda: process_inout('(a,b,cc) ? (d,ee)'), contains='Too much parenthesis')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "22f7d40b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "def separate_args_and_inout(x):\n",
+    "    if x is None: return None\n",
+    "    if (start_t := optional_find(x,['(','->'],reverse=False)) and (end_t := optional_find(x,[')','->'],reverse=True)):\n",
+    "        start,_ = start_t\n",
+    "        end, c = end_t\n",
+    "        length = len(c)\n",
+    "        return x[:start]+x[end+length:],x[start:end+length]\n",
+    "    return x,None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "228f1202",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_eq(separate_args_and_inout(None), None)  # None input → None output\n",
+    "\n",
+    "test_eq(separate_args_and_inout(''), ['', None])  # Empty string → empty args, no in/out\n",
+    "test_eq(separate_args_and_inout('verbose'), ['verbose', None])  # Only args, no in/out\n",
+    "test_eq(separate_args_and_inout('dryrun verbose'), ['dryrun verbose', None])  # Multiple args, no in/out\n",
+    "test_eq(separate_args_and_inout('(a,b)->(c,d)'), ['', '(a,b)->(c,d)'])  # Pure in/out spec, no args\n",
+    "test_eq(separate_args_and_inout('(a,b)'), ['', '(a,b)'])  # Only input tuple, no args\n",
+    "test_eq(separate_args_and_inout('->(c,d)'), ['', '->(c,d)'])  # Only output tuple, no args\n",
+    "\n",
+    "test_eq(separate_args_and_inout('dryrun verbose (a,b)'), ['dryrun verbose ', '(a,b)'])  # Args + input tuple\n",
+    "test_eq(separate_args_and_inout('dryrun verbose (a,b) -> (c,d) '), ['dryrun verbose  ', '(a,b) -> (c,d)'])  # Args + in/out\n",
+    "test_eq(separate_args_and_inout('dryrun verbose  () -> (c,d) '), ['dryrun verbose   ', '() -> (c,d)'])  # Args + empty input tuple\n",
+    "test_eq(separate_args_and_inout('dryrun verbose (a,b) -> ()'), ['dryrun verbose ', '(a,b) -> ()'])  # Args + empty output tuple\n",
+    "test_eq(separate_args_and_inout('dryrun verbose (a,b)  '), ['dryrun verbose   ', '(a,b)'])  # Args + input tuple, trailing spaces\n",
+    "\n",
+    "test_eq(separate_args_and_inout('dryrun  (a,b)  verbose '), ['dryrun    verbose ', '(a,b)'])  # In/out tuple between args\n",
+    "test_eq(separate_args_and_inout('dryrun  (a,b) -> (c,d) verbose'), ['dryrun   verbose', '(a,b) -> (c,d)'])  # In/out in middle of args\n",
+    "test_eq(separate_args_and_inout('dryrun () -> (c,d) verbose'), ['dryrun  verbose', '() -> (c,d)'])  # Empty input tuple\n",
+    "test_eq(separate_args_and_inout('dryrun () -> (c,d)verbose'), ['dryrun verbose', '() -> (c,d)'])  # No space before verbose\n",
+    "test_eq(separate_args_and_inout('dryrun() -> (c,d) verbose'), ['dryrun verbose', '() -> (c,d)'])  # No space before ()\n",
+    "test_eq(separate_args_and_inout('dryrun  (a,b)->() verbose'), ['dryrun   verbose', '(a,b)->()'])  # Compact arrow, spacing preserved\n",
+    "test_eq(separate_args_and_inout('dryrun (a, b)  verbose'), ['dryrun   verbose', '(a, b)'])  # Tuple spacing preserved\n",
+    "\n",
+    "test_eq(separate_args_and_inout('dryrun -> (c,d)verbose'), ['dryrun verbose', '-> (c,d)'])  # Output tuple glued to arg\n",
+    "test_eq(separate_args_and_inout('dryrun (c,d)->verbose'), ['dryrun verbose', '(c,d)->'])  # Input tuple glued to arg\n",
+    "\n",
+    "test_eq(separate_args_and_inout('dryrun (incomplete'), ['dryrun (incomplete', None])  # Unclosed parenthesis → ignore as in/out"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "104897cf",
+   "metadata": {},
+   "source": [
+    "## Consume inout"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2e72903f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "def validate_and_update_inputs(inputs:list,state:dict,)->dict:\n",
+    "  s = set(inputs)\n",
+    "  ret = {}\n",
+    "  missing = []\n",
+    "  for k in inputs:\n",
+    "      if k not in state:\n",
+    "          missing.append(k)\n",
+    "      else:\n",
+    "          ret[k] = state[k]\n",
+    "\n",
+    "  if missing:\n",
+    "      # Generic error that doesn't reveal what DOES exist\n",
+    "      raise ValueError(f'Required input variable(s) not found: {\", \".join(missing)}')\n",
+    "\n",
+    "  return ret"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c95e8718",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_eq( validate_and_update_inputs(['a'],{'a':1, 'b':2}) , {'a':1} )\n",
+    "test_fail(lambda: validate_and_update_inputs(['a'],{'b':1}) , contains='not found: a' )\n",
+    "test_fail(lambda: validate_and_update_inputs(['a','c'],{'b':1}) , contains='not found: a, c' )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ba812f8b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| hide\n",
+    "import nbdev; nbdev.nbdev_export()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "python3",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/nbs/02_testcell.ipynb b/nbs/02_testcell.ipynb
index 90989da..52ee1e1 100644
--- a/nbs/02_testcell.ipynb
+++ b/nbs/02_testcell.ipynb
@@ -41,8 +41,15 @@
     "#| export\n",
     "import ast\n",
     "from IPython.core.magic import register_cell_magic, needs_local_scope\n",
-    "from IPython import get_ipython # needed for quarto\n",
-    "from IPython.display import Code"
+    "from IPython import get_ipython # needed for quarto"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "WARNING: the official `IPython.display.Code` syntax hilighter don't seems to work. We're creating a \"drop-in\" replacement that force `full=True` in HtmlFormatter. This seems to work properly and give us more control on code display.\n",
+    "For details see: https://github.com/ipython/ipython/blob/72bb67ee8f57cb347ba358cce786c3fa87c470b9/IPython/lib/display.py#L667"
    ]
   },
   {
@@ -52,7 +59,8 @@
    "outputs": [],
    "source": [
     "#| export\n",
-    "from testcell.core import auto_return"
+    "from testcell.core import auto_return\n",
+    "from testcell.inout import separate_args_and_inout, process_inout, split_and_strip, validate_and_update_inputs"
    ]
   },
   {
@@ -80,6 +88,16 @@
     "## Support classes "
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Used only in tests\n",
+    "from fastcore.test import *"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -87,20 +105,26 @@
    "outputs": [],
    "source": [
     "#| export\n",
-    "# Temporary class to deal with different display options (jupyter or console)\n",
+    "import html\n",
+    "\n",
     "class MessageBox:\n",
     "    def __init__(self,data,*,background_color,text_color,emoji=None):\n",
     "        self.data = data\n",
     "        self.background_color = background_color\n",
     "        self.text_color = text_color\n",
     "        self.emoji = emoji\n",
-    "\n",
+    "        \n",
     "    def _repr_html_(self):\n",
+    "        # Escape all user-controllable values\n",
+    "        safe_bg = html.escape(str(self.background_color), quote=True)\n",
+    "        safe_text = html.escape(str(self.text_color), quote=True)\n",
+    "        safe_data = html.escape(str(self.data))\n",
+    "        \n",
     "        return f\"\"\"\n",
-    "        <div style=\"background-color: {self.background_color}; padding: 3px; text-align: center; font-size: 12px; color: {self.text_color};\">\n",
-    "            {self.data}\n",
-    "        </div>\n",
-    "        \"\"\"\n",
+    "            <div style=\"background-color: {safe_bg}; padding: 3px; text-align: center; font-size: 12px; color: {safe_text};\">\n",
+    "              {safe_data}\n",
+    "            </div>\n",
+    "            \"\"\"\n",
     "\n",
     "    def __repr__(self): \n",
     "        text = self.data\n",
@@ -108,6 +132,19 @@
     "        return text"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# test against html injection\n",
+    "mb = MessageBox('<script>alert(1)</script>', background_color='red', text_color='black')\n",
+    "test_eq('&lt;script&gt;' in mb._repr_html_(), True)  # Escaped = GOOD\n",
+    "test_eq('<script>' in mb._repr_html_(), False)  # No raw script = GOOD\n",
+    "del mb # we need to manually cleanup because we don't have %%testcell ;-)"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -129,10 +166,10 @@
      "data": {
       "text/html": [
        "\n",
-       "        <div style=\"background-color: #808080; padding: 3px; text-align: center; font-size: 12px; color: white;\">\n",
-       "            This cell has been skipped\n",
-       "        </div>\n",
-       "        "
+       "            <div style=\"background-color: #808080; padding: 3px; text-align: center; font-size: 12px; color: white;\">\n",
+       "              This cell has been skipped\n",
+       "            </div>\n",
+       "            "
       ],
       "text/plain": [
        "ℹ️ This cell has been skipped"
@@ -145,10 +182,10 @@
      "data": {
       "text/html": [
        "\n",
-       "        <div style=\"background-color: yellow; padding: 3px; text-align: center; font-size: 12px; color: black;\">\n",
-       "            testcell\n",
-       "        </div>\n",
-       "        "
+       "            <div style=\"background-color: yellow; padding: 3px; text-align: center; font-size: 12px; color: black;\">\n",
+       "              testcell\n",
+       "            </div>\n",
+       "            "
       ],
       "text/plain": [
        "🟡 testcell"
@@ -161,10 +198,10 @@
      "data": {
       "text/html": [
        "\n",
-       "        <div style=\"background-color: green; padding: 3px; text-align: center; font-size: 12px; color: white;\">\n",
-       "            testcell noglobals\n",
-       "        </div>\n",
-       "        "
+       "            <div style=\"background-color: green; padding: 3px; text-align: center; font-size: 12px; color: white;\">\n",
+       "              testcell noglobals\n",
+       "            </div>\n",
+       "            "
       ],
       "text/plain": [
        "🟢 testcell noglobals"
@@ -201,6 +238,210 @@
     "[print(o.__repr__()) for o in [skip_message_box,testcell_message_box,noglobals_message_box]];"
    ]
   },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "# Skipped because it don't show the \n",
+    "from IPython.display import Code"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "# Correct colors in jupyter but don't get exported properly and pollutes each cell with a copy of css\n",
+    "from pygments.formatters import HtmlFormatter\n",
+    "from pygments import highlight\n",
+    "from pygments.lexers import PythonLexer\n",
+    "from IPython.display import HTML\n",
+    "\n",
+    "class Code:\n",
+    "    def __init__(self, data=None, url=None, filename=None, language=None):\n",
+    "        self.data = data\n",
+    "        # NOTE: skipping other arguments, we're keeling them only for backward compatibility\n",
+    "    def _repr_html_(self): return highlight(self.data, PythonLexer(), HtmlFormatter(full=True))\n",
+    "    def __repr__(self): return self.data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "from IPython.display import Markdown\n",
+    "\n",
+    "class Code:\n",
+    "    def __init__(self, data=None, url=None, filename=None, language='python'):\n",
+    "        self.data = data\n",
+    "        self.language = language\n",
+    "        # NOTE: skipping other arguments, we're keeling them only for backward compatibility\n",
+    "    def _repr_markdown_(self): return Markdown(f\"```{self.language}\\n{self.data}\\n```\")._repr_markdown_()\n",
+    "    def __repr__(self): return self.data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "```python\n",
+       "\n",
+       "# This is a comment\n",
+       "class A:\n",
+       "   def b(self): return 1\n",
+       "\n",
+       "def c(): return 3\n",
+       "\n",
+       "```"
+      ],
+      "text/plain": [
+       "\n",
+       "# This is a comment\n",
+       "class A:\n",
+       "   def b(self): return 1\n",
+       "\n",
+       "def c(): return 3"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# test rendering inside jupyter\n",
+    "Code('''\n",
+    "# This is a comment\n",
+    "class A:\n",
+    "   def b(self): return 1\n",
+    "\n",
+    "def c(): return 3\n",
+    "''')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "# This is a comment\n",
+      "class A:\n",
+      "   def b(self): return 1\n",
+      "\n",
+      "def c(): return 3\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# test rendering in console\n",
+    "print(Code('''\n",
+    "# This is a comment\n",
+    "class A:\n",
+    "   def b(self): return 1\n",
+    "\n",
+    "def c(): return 3\n",
+    "''').__repr__())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Valid arguments"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export \n",
+    "testcell_valid_args = {'verbose','dryrun','noglobals','noreturn','skip','banner','debug'} # full commands set"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export \n",
+    "def parse_args(x):\n",
+    "    t = set([c for c in split_and_strip(x,' ') if c != ''])\n",
+    "    diff = t.difference(testcell_valid_args)\n",
+    "    if len(diff)>0: raise ValueError(f'Invalid arguments passed: \"{\",\".join(diff)}\"')\n",
+    "    return t"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_eq(parse_args(''),set())\n",
+    "test_eq(parse_args('verbose dryrun'),{'dryrun', 'verbose'})\n",
+    "test_eq(parse_args('verbose dryrun '),{'dryrun', 'verbose'})\n",
+    "test_fail(lambda:parse_args('verbose dryrun xxx yyy'),contains='Invalid arguments passed')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Parse testcell arguments string"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "from collections import namedtuple\n",
+    "TestcellArgs = namedtuple('TestcellArgs','args inout')\n",
+    "Inout = namedtuple('Inout','input output')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "def parse_testcell_args(x:str)->TestcellArgs:\n",
+    "    raw_args,raw_inout = separate_args_and_inout(x)\n",
+    "    return TestcellArgs(parse_args(raw_args),None if raw_inout is None else Inout(*process_inout(raw_inout)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_eq(parse_testcell_args('dryrun  verbose '),TestcellArgs({'dryrun','verbose'},None))\n",
+    "test_eq(parse_testcell_args('dryrun verbose (a,b)'),TestcellArgs({'dryrun','verbose'},Inout(['a','b'],[])))\n",
+    "test_eq(parse_testcell_args('dryrun verbose (a,b) ->(c)'),TestcellArgs({'dryrun','verbose'},Inout(['a','b'],['c'])))\n",
+    "\n",
+    "test_fail(lambda:parse_testcell_args('dryrun verbose (a,b) ->c'), contains='Invalid arguments passed')"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -218,6 +459,8 @@
     "@register_cell_magic\n",
     "@needs_local_scope\n",
     "def testcell(line, cell, local_ns):\n",
+    "    args,inout = parse_testcell_args(line)\n",
+    "    \n",
     "    # Parse arguments\n",
     "    verbose = 'verbose' in line # enable verbose \n",
     "    dryrun = 'dryrun' in line # this will avoid running the code and just print out the code like verbose\n",
@@ -225,23 +468,37 @@
     "    noreturn = 'noreturn' in line # display but does not return anything, so no memory \"footprint\" after execution\n",
     "    skip = ('skip' in line) or global_skip # skip cell execution\n",
     "    use_banner = ('banner' in line) or global_use_banner # shows a contextual banner at top of the cell\n",
+    "    debug = 'debug' in args # debug mode shows both code and all the update to the globals \n",
     "    \n",
     "    # arguments rules\n",
     "    if noglobals or dryrun: noreturn=True\n",
     "    if dryrun: verbose=True\n",
+    "    if debug: verbose=True\n",
     "\n",
     "    # skip\n",
     "    if skip: \n",
     "        display(skip_message_box)\n",
     "        return None # exits\n",
-    "\n",
     "    \n",
     "    # Do the job\n",
     "    cell = auto_return(cell)\n",
     "    lines = cell.splitlines()\n",
+    "    \n",
+    "    # Globals management\n",
+    "    _globals = {} if noglobals else local_ns\n",
+    "    _locals = {'_':None} if noreturn else None # we mask '_' with a local variable to prevent it affecting global scope\n",
     "\n",
+    "    # Deal with inout\n",
+    "    outputs = None\n",
+    "    globals_definitions = []\n",
+    "    if inout is not None:\n",
+    "        inputs,outputs = inout.input,inout.output\n",
+    "        _globals.update(validate_and_update_inputs(inputs,local_ns)) # inputs\n",
+    "        for o in outputs: globals_definitions += ['\\t'+f'global {o}'] # outputs\n",
+    "    \n",
     "    # Wrap inside a function and execute it\n",
     "    arr = ['def _test_cell_():']\n",
+    "    arr += globals_definitions\n",
     "    arr += ['\\t'+x for x in lines]\n",
     "    arr += ['try:\\n\\t_ = _test_cell_()'] # execute it and assign result to '_'\n",
     "    arr += ['finally:\\n\\tdel _test_cell_'] # delete it\n",
@@ -251,14 +508,18 @@
     "        arr += ['_ # This will be added to global scope'] # having this as last line makes the same behavior as normal cell\n",
     "    wrapped_cell = '\\n'.join(arr)\n",
     "\n",
-    "    if verbose: display(Code('\\n### BEGIN\\n'+wrapped_cell+'\\n### END',language='python'))\n",
+    "    if use_banner: display(noglobals_message_box if noglobals else testcell_message_box)\n",
+    "    if verbose: display(Code('### BEGIN\\n'+wrapped_cell+'\\n### END',language='python'))\n",
     "\n",
-    "    _globals = {} if noglobals else local_ns\n",
-    "    _locals = {'_':None} if noreturn else None # we mask '_' with a local variable to prevent it affecting global scope\n",
-    "    if not 'dryrun' in line: \n",
-    "        if use_banner: display(noglobals_message_box if noglobals else testcell_message_box)\n",
-    "        exec(wrapped_cell,_globals,_locals)\n",
-    "    \n",
+    "    if not dryrun: exec(wrapped_cell,_globals,_locals)\n",
+    "        \n",
+    "    if (outputs is not None) and (len(outputs)>0) and (not dryrun):\n",
+    "        arr2 = []\n",
+    "        for o in outputs: arr2 += [f'global {o}; {o}=locals()[\"{o}\"]'] # this forwards objects to global scope\n",
+    "        globals_update_code = '\\n'.join(arr2)\n",
+    "        if debug: display(Code('### GLOBALS UPDATE CODE:\\n'+globals_update_code+'\\n###',language='python'))\n",
+    "        exec(globals_update_code,local_ns,_globals)\n",
+    "        \n",
     "    return None if noreturn else _globals.get('_',None) # this closes the loop of integration"
    ]
   },
@@ -746,110 +1007,22 @@
    "outputs": [
     {
      "data": {
-      "text/html": [
-       "<style>pre { line-height: 125%; }\n",
-       "td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
-       "span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
-       "td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
-       "span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
-       ".output_html .hll { background-color: #ffffcc }\n",
-       ".output_html { background: #f8f8f8; }\n",
-       ".output_html .c { color: #3D7B7B; font-style: italic } /* Comment */\n",
-       ".output_html .err { border: 1px solid #FF0000 } /* Error */\n",
-       ".output_html .k { color: #008000; font-weight: bold } /* Keyword */\n",
-       ".output_html .o { color: #666666 } /* Operator */\n",
-       ".output_html .ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */\n",
-       ".output_html .cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */\n",
-       ".output_html .cp { color: #9C6500 } /* Comment.Preproc */\n",
-       ".output_html .cpf { color: #3D7B7B; font-style: italic } /* Comment.PreprocFile */\n",
-       ".output_html .c1 { color: #3D7B7B; font-style: italic } /* Comment.Single */\n",
-       ".output_html .cs { color: #3D7B7B; font-style: italic } /* Comment.Special */\n",
-       ".output_html .gd { color: #A00000 } /* Generic.Deleted */\n",
-       ".output_html .ge { font-style: italic } /* Generic.Emph */\n",
-       ".output_html .gr { color: #E40000 } /* Generic.Error */\n",
-       ".output_html .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
-       ".output_html .gi { color: #008400 } /* Generic.Inserted */\n",
-       ".output_html .go { color: #717171 } /* Generic.Output */\n",
-       ".output_html .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
-       ".output_html .gs { font-weight: bold } /* Generic.Strong */\n",
-       ".output_html .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       ".output_html .gt { color: #0044DD } /* Generic.Traceback */\n",
-       ".output_html .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
-       ".output_html .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
-       ".output_html .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
-       ".output_html .kp { color: #008000 } /* Keyword.Pseudo */\n",
-       ".output_html .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
-       ".output_html .kt { color: #B00040 } /* Keyword.Type */\n",
-       ".output_html .m { color: #666666 } /* Literal.Number */\n",
-       ".output_html .s { color: #BA2121 } /* Literal.String */\n",
-       ".output_html .na { color: #687822 } /* Name.Attribute */\n",
-       ".output_html .nb { color: #008000 } /* Name.Builtin */\n",
-       ".output_html .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       ".output_html .no { color: #880000 } /* Name.Constant */\n",
-       ".output_html .nd { color: #AA22FF } /* Name.Decorator */\n",
-       ".output_html .ni { color: #717171; font-weight: bold } /* Name.Entity */\n",
-       ".output_html .ne { color: #CB3F38; font-weight: bold } /* Name.Exception */\n",
-       ".output_html .nf { color: #0000FF } /* Name.Function */\n",
-       ".output_html .nl { color: #767600 } /* Name.Label */\n",
-       ".output_html .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
-       ".output_html .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
-       ".output_html .nv { color: #19177C } /* Name.Variable */\n",
-       ".output_html .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       ".output_html .w { color: #bbbbbb } /* Text.Whitespace */\n",
-       ".output_html .mb { color: #666666 } /* Literal.Number.Bin */\n",
-       ".output_html .mf { color: #666666 } /* Literal.Number.Float */\n",
-       ".output_html .mh { color: #666666 } /* Literal.Number.Hex */\n",
-       ".output_html .mi { color: #666666 } /* Literal.Number.Integer */\n",
-       ".output_html .mo { color: #666666 } /* Literal.Number.Oct */\n",
-       ".output_html .sa { color: #BA2121 } /* Literal.String.Affix */\n",
-       ".output_html .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
-       ".output_html .sc { color: #BA2121 } /* Literal.String.Char */\n",
-       ".output_html .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
-       ".output_html .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
-       ".output_html .s2 { color: #BA2121 } /* Literal.String.Double */\n",
-       ".output_html .se { color: #AA5D1F; font-weight: bold } /* Literal.String.Escape */\n",
-       ".output_html .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
-       ".output_html .si { color: #A45A77; font-weight: bold } /* Literal.String.Interpol */\n",
-       ".output_html .sx { color: #008000 } /* Literal.String.Other */\n",
-       ".output_html .sr { color: #A45A77 } /* Literal.String.Regex */\n",
-       ".output_html .s1 { color: #BA2121 } /* Literal.String.Single */\n",
-       ".output_html .ss { color: #19177C } /* Literal.String.Symbol */\n",
-       ".output_html .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       ".output_html .fm { color: #0000FF } /* Name.Function.Magic */\n",
-       ".output_html .vc { color: #19177C } /* Name.Variable.Class */\n",
-       ".output_html .vg { color: #19177C } /* Name.Variable.Global */\n",
-       ".output_html .vi { color: #19177C } /* Name.Variable.Instance */\n",
-       ".output_html .vm { color: #19177C } /* Name.Variable.Magic */\n",
-       ".output_html .il { color: #666666 } /* Literal.Number.Integer.Long */</style><div class=\"highlight\"><pre><span></span><span class=\"c1\">### BEGIN</span>\n",
-       "<span class=\"k\">def</span> <span class=\"nf\">_test_cell_</span><span class=\"p\">():</span>\n",
-       "\t<span class=\"c1\"># %%testcell verbose</span>\n",
-       "\t<span class=\"n\">b</span><span class=\"o\">=</span><span class=\"mi\">3</span>\n",
-       "\t<span class=\"k\">return</span> <span class=\"n\">b</span> <span class=\"c1\"># %%testcell</span>\n",
-       "<span class=\"k\">try</span><span class=\"p\">:</span>\n",
-       "\t<span class=\"n\">_</span> <span class=\"o\">=</span> <span class=\"n\">_test_cell_</span><span class=\"p\">()</span>\n",
-       "<span class=\"k\">finally</span><span class=\"p\">:</span>\n",
-       "\t<span class=\"k\">del</span> <span class=\"n\">_test_cell_</span>\n",
-       "<span class=\"n\">_</span> <span class=\"c1\"># This will be added to global scope</span>\n",
-       "<span class=\"c1\">### END</span>\n",
-       "</pre></div>\n"
-      ],
-      "text/latex": [
-       "\\begin{Verbatim}[commandchars=\\\\\\{\\}]\n",
-       "\\PY{c+c1}{\\PYZsh{}\\PYZsh{}\\PYZsh{} BEGIN}\n",
-       "\\PY{k}{def} \\PY{n+nf}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\\PY{p}{(}\\PY{p}{)}\\PY{p}{:}\n",
-       "\t\\PY{c+c1}{\\PYZsh{} \\PYZpc{}\\PYZpc{}testcell verbose}\n",
-       "\t\\PY{n}{b}\\PY{o}{=}\\PY{l+m+mi}{3}\n",
-       "\t\\PY{k}{return} \\PY{n}{b} \\PY{c+c1}{\\PYZsh{} \\PYZpc{}\\PYZpc{}testcell}\n",
-       "\\PY{k}{try}\\PY{p}{:}\n",
-       "\t\\PY{n}{\\PYZus{}} \\PY{o}{=} \\PY{n}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\\PY{p}{(}\\PY{p}{)}\n",
-       "\\PY{k}{finally}\\PY{p}{:}\n",
-       "\t\\PY{k}{del} \\PY{n}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\n",
-       "\\PY{n}{\\PYZus{}} \\PY{c+c1}{\\PYZsh{} This will be added to global scope}\n",
-       "\\PY{c+c1}{\\PYZsh{}\\PYZsh{}\\PYZsh{} END}\n",
-       "\\end{Verbatim}\n"
+      "text/markdown": [
+       "```python\n",
+       "### BEGIN\n",
+       "def _test_cell_():\n",
+       "\t# %%testcell verbose\n",
+       "\tb=3\n",
+       "\treturn b # %%testcell\n",
+       "try:\n",
+       "\t_ = _test_cell_()\n",
+       "finally:\n",
+       "\tdel _test_cell_\n",
+       "_ # This will be added to global scope\n",
+       "### END\n",
+       "```"
       ],
       "text/plain": [
-       "\n",
        "### BEGIN\n",
        "def _test_cell_():\n",
        "\t# %%testcell verbose\n",
@@ -900,114 +1073,24 @@
    "outputs": [
     {
      "data": {
-      "text/html": [
-       "<style>pre { line-height: 125%; }\n",
-       "td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
-       "span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
-       "td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
-       "span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
-       ".output_html .hll { background-color: #ffffcc }\n",
-       ".output_html { background: #f8f8f8; }\n",
-       ".output_html .c { color: #3D7B7B; font-style: italic } /* Comment */\n",
-       ".output_html .err { border: 1px solid #FF0000 } /* Error */\n",
-       ".output_html .k { color: #008000; font-weight: bold } /* Keyword */\n",
-       ".output_html .o { color: #666666 } /* Operator */\n",
-       ".output_html .ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */\n",
-       ".output_html .cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */\n",
-       ".output_html .cp { color: #9C6500 } /* Comment.Preproc */\n",
-       ".output_html .cpf { color: #3D7B7B; font-style: italic } /* Comment.PreprocFile */\n",
-       ".output_html .c1 { color: #3D7B7B; font-style: italic } /* Comment.Single */\n",
-       ".output_html .cs { color: #3D7B7B; font-style: italic } /* Comment.Special */\n",
-       ".output_html .gd { color: #A00000 } /* Generic.Deleted */\n",
-       ".output_html .ge { font-style: italic } /* Generic.Emph */\n",
-       ".output_html .gr { color: #E40000 } /* Generic.Error */\n",
-       ".output_html .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
-       ".output_html .gi { color: #008400 } /* Generic.Inserted */\n",
-       ".output_html .go { color: #717171 } /* Generic.Output */\n",
-       ".output_html .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
-       ".output_html .gs { font-weight: bold } /* Generic.Strong */\n",
-       ".output_html .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       ".output_html .gt { color: #0044DD } /* Generic.Traceback */\n",
-       ".output_html .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
-       ".output_html .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
-       ".output_html .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
-       ".output_html .kp { color: #008000 } /* Keyword.Pseudo */\n",
-       ".output_html .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
-       ".output_html .kt { color: #B00040 } /* Keyword.Type */\n",
-       ".output_html .m { color: #666666 } /* Literal.Number */\n",
-       ".output_html .s { color: #BA2121 } /* Literal.String */\n",
-       ".output_html .na { color: #687822 } /* Name.Attribute */\n",
-       ".output_html .nb { color: #008000 } /* Name.Builtin */\n",
-       ".output_html .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       ".output_html .no { color: #880000 } /* Name.Constant */\n",
-       ".output_html .nd { color: #AA22FF } /* Name.Decorator */\n",
-       ".output_html .ni { color: #717171; font-weight: bold } /* Name.Entity */\n",
-       ".output_html .ne { color: #CB3F38; font-weight: bold } /* Name.Exception */\n",
-       ".output_html .nf { color: #0000FF } /* Name.Function */\n",
-       ".output_html .nl { color: #767600 } /* Name.Label */\n",
-       ".output_html .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
-       ".output_html .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
-       ".output_html .nv { color: #19177C } /* Name.Variable */\n",
-       ".output_html .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       ".output_html .w { color: #bbbbbb } /* Text.Whitespace */\n",
-       ".output_html .mb { color: #666666 } /* Literal.Number.Bin */\n",
-       ".output_html .mf { color: #666666 } /* Literal.Number.Float */\n",
-       ".output_html .mh { color: #666666 } /* Literal.Number.Hex */\n",
-       ".output_html .mi { color: #666666 } /* Literal.Number.Integer */\n",
-       ".output_html .mo { color: #666666 } /* Literal.Number.Oct */\n",
-       ".output_html .sa { color: #BA2121 } /* Literal.String.Affix */\n",
-       ".output_html .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
-       ".output_html .sc { color: #BA2121 } /* Literal.String.Char */\n",
-       ".output_html .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
-       ".output_html .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
-       ".output_html .s2 { color: #BA2121 } /* Literal.String.Double */\n",
-       ".output_html .se { color: #AA5D1F; font-weight: bold } /* Literal.String.Escape */\n",
-       ".output_html .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
-       ".output_html .si { color: #A45A77; font-weight: bold } /* Literal.String.Interpol */\n",
-       ".output_html .sx { color: #008000 } /* Literal.String.Other */\n",
-       ".output_html .sr { color: #A45A77 } /* Literal.String.Regex */\n",
-       ".output_html .s1 { color: #BA2121 } /* Literal.String.Single */\n",
-       ".output_html .ss { color: #19177C } /* Literal.String.Symbol */\n",
-       ".output_html .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       ".output_html .fm { color: #0000FF } /* Name.Function.Magic */\n",
-       ".output_html .vc { color: #19177C } /* Name.Variable.Class */\n",
-       ".output_html .vg { color: #19177C } /* Name.Variable.Global */\n",
-       ".output_html .vi { color: #19177C } /* Name.Variable.Instance */\n",
-       ".output_html .vm { color: #19177C } /* Name.Variable.Magic */\n",
-       ".output_html .il { color: #666666 } /* Literal.Number.Integer.Long */</style><div class=\"highlight\"><pre><span></span><span class=\"c1\">### BEGIN</span>\n",
-       "<span class=\"k\">def</span> <span class=\"nf\">_test_cell_</span><span class=\"p\">():</span>\n",
-       "\t<span class=\"c1\"># %%testcell dryrun</span>\n",
-       "\t<span class=\"n\">b</span><span class=\"o\">=</span><span class=\"mi\">1</span>\n",
-       "\t<span class=\"n\">b</span>\n",
-       "\t\n",
-       "\t<span class=\"k\">assert</span> <span class=\"kc\">False</span> <span class=\"c1\"># we should not be here because code is supposed to not be executed</span>\n",
-       "<span class=\"k\">try</span><span class=\"p\">:</span>\n",
-       "\t<span class=\"n\">_</span> <span class=\"o\">=</span> <span class=\"n\">_test_cell_</span><span class=\"p\">()</span>\n",
-       "<span class=\"k\">finally</span><span class=\"p\">:</span>\n",
-       "\t<span class=\"k\">del</span> <span class=\"n\">_test_cell_</span>\n",
-       "<span class=\"k\">if</span> <span class=\"n\">_</span> <span class=\"ow\">is</span> <span class=\"ow\">not</span> <span class=\"kc\">None</span><span class=\"p\">:</span> <span class=\"n\">display</span><span class=\"p\">(</span><span class=\"n\">_</span><span class=\"p\">)</span>\n",
-       "<span class=\"c1\">### END</span>\n",
-       "</pre></div>\n"
-      ],
-      "text/latex": [
-       "\\begin{Verbatim}[commandchars=\\\\\\{\\}]\n",
-       "\\PY{c+c1}{\\PYZsh{}\\PYZsh{}\\PYZsh{} BEGIN}\n",
-       "\\PY{k}{def} \\PY{n+nf}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\\PY{p}{(}\\PY{p}{)}\\PY{p}{:}\n",
-       "\t\\PY{c+c1}{\\PYZsh{} \\PYZpc{}\\PYZpc{}testcell dryrun}\n",
-       "\t\\PY{n}{b}\\PY{o}{=}\\PY{l+m+mi}{1}\n",
-       "\t\\PY{n}{b}\n",
+      "text/markdown": [
+       "```python\n",
+       "### BEGIN\n",
+       "def _test_cell_():\n",
+       "\t# %%testcell dryrun\n",
+       "\tb=1\n",
+       "\tb\n",
        "\t\n",
-       "\t\\PY{k}{assert} \\PY{k+kc}{False} \\PY{c+c1}{\\PYZsh{} we should not be here because code is supposed to not be executed}\n",
-       "\\PY{k}{try}\\PY{p}{:}\n",
-       "\t\\PY{n}{\\PYZus{}} \\PY{o}{=} \\PY{n}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\\PY{p}{(}\\PY{p}{)}\n",
-       "\\PY{k}{finally}\\PY{p}{:}\n",
-       "\t\\PY{k}{del} \\PY{n}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\n",
-       "\\PY{k}{if} \\PY{n}{\\PYZus{}} \\PY{o+ow}{is} \\PY{o+ow}{not} \\PY{k+kc}{None}\\PY{p}{:} \\PY{n}{display}\\PY{p}{(}\\PY{n}{\\PYZus{}}\\PY{p}{)}\n",
-       "\\PY{c+c1}{\\PYZsh{}\\PYZsh{}\\PYZsh{} END}\n",
-       "\\end{Verbatim}\n"
+       "\tassert False # we should not be here because code is supposed to not be executed\n",
+       "try:\n",
+       "\t_ = _test_cell_()\n",
+       "finally:\n",
+       "\tdel _test_cell_\n",
+       "if _ is not None: display(_)\n",
+       "### END\n",
+       "```"
       ],
       "text/plain": [
-       "\n",
        "### BEGIN\n",
        "def _test_cell_():\n",
        "\t# %%testcell dryrun\n",
@@ -1052,10 +1135,10 @@
      "data": {
       "text/html": [
        "\n",
-       "        <div style=\"background-color: #808080; padding: 3px; text-align: center; font-size: 12px; color: white;\">\n",
-       "            This cell has been skipped\n",
-       "        </div>\n",
-       "        "
+       "            <div style=\"background-color: #808080; padding: 3px; text-align: center; font-size: 12px; color: white;\">\n",
+       "              This cell has been skipped\n",
+       "            </div>\n",
+       "            "
       ],
       "text/plain": [
        "ℹ️ This cell has been skipped"
@@ -1080,10 +1163,10 @@
      "data": {
       "text/html": [
        "\n",
-       "        <div style=\"background-color: yellow; padding: 3px; text-align: center; font-size: 12px; color: black;\">\n",
-       "            testcell\n",
-       "        </div>\n",
-       "        "
+       "            <div style=\"background-color: yellow; padding: 3px; text-align: center; font-size: 12px; color: black;\">\n",
+       "              testcell\n",
+       "            </div>\n",
+       "            "
       ],
       "text/plain": [
        "🟡 testcell"
@@ -1113,6 +1196,47 @@
     "Markdown('''This shows a contextual banner, use: `testcell.global_use_banner=True` to always show the banner''')"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "            <div style=\"background-color: green; padding: 3px; text-align: center; font-size: 12px; color: white;\">\n",
+       "              testcell noglobals\n",
+       "            </div>\n",
+       "            "
+      ],
+      "text/plain": [
+       "🟢 testcell noglobals"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "This is a banner for noglobals"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcelln banner\n",
+    "# %%testcelln banner\n",
+    "from IPython.display import Markdown\n",
+    "Markdown('''This is a banner for noglobals''')"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -1218,111 +1342,24 @@
    "outputs": [
     {
      "data": {
-      "text/html": [
-       "<style>pre { line-height: 125%; }\n",
-       "td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
-       "span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
-       "td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
-       "span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
-       ".output_html .hll { background-color: #ffffcc }\n",
-       ".output_html { background: #f8f8f8; }\n",
-       ".output_html .c { color: #3D7B7B; font-style: italic } /* Comment */\n",
-       ".output_html .err { border: 1px solid #FF0000 } /* Error */\n",
-       ".output_html .k { color: #008000; font-weight: bold } /* Keyword */\n",
-       ".output_html .o { color: #666666 } /* Operator */\n",
-       ".output_html .ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */\n",
-       ".output_html .cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */\n",
-       ".output_html .cp { color: #9C6500 } /* Comment.Preproc */\n",
-       ".output_html .cpf { color: #3D7B7B; font-style: italic } /* Comment.PreprocFile */\n",
-       ".output_html .c1 { color: #3D7B7B; font-style: italic } /* Comment.Single */\n",
-       ".output_html .cs { color: #3D7B7B; font-style: italic } /* Comment.Special */\n",
-       ".output_html .gd { color: #A00000 } /* Generic.Deleted */\n",
-       ".output_html .ge { font-style: italic } /* Generic.Emph */\n",
-       ".output_html .gr { color: #E40000 } /* Generic.Error */\n",
-       ".output_html .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
-       ".output_html .gi { color: #008400 } /* Generic.Inserted */\n",
-       ".output_html .go { color: #717171 } /* Generic.Output */\n",
-       ".output_html .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
-       ".output_html .gs { font-weight: bold } /* Generic.Strong */\n",
-       ".output_html .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       ".output_html .gt { color: #0044DD } /* Generic.Traceback */\n",
-       ".output_html .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
-       ".output_html .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
-       ".output_html .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
-       ".output_html .kp { color: #008000 } /* Keyword.Pseudo */\n",
-       ".output_html .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
-       ".output_html .kt { color: #B00040 } /* Keyword.Type */\n",
-       ".output_html .m { color: #666666 } /* Literal.Number */\n",
-       ".output_html .s { color: #BA2121 } /* Literal.String */\n",
-       ".output_html .na { color: #687822 } /* Name.Attribute */\n",
-       ".output_html .nb { color: #008000 } /* Name.Builtin */\n",
-       ".output_html .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       ".output_html .no { color: #880000 } /* Name.Constant */\n",
-       ".output_html .nd { color: #AA22FF } /* Name.Decorator */\n",
-       ".output_html .ni { color: #717171; font-weight: bold } /* Name.Entity */\n",
-       ".output_html .ne { color: #CB3F38; font-weight: bold } /* Name.Exception */\n",
-       ".output_html .nf { color: #0000FF } /* Name.Function */\n",
-       ".output_html .nl { color: #767600 } /* Name.Label */\n",
-       ".output_html .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
-       ".output_html .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
-       ".output_html .nv { color: #19177C } /* Name.Variable */\n",
-       ".output_html .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       ".output_html .w { color: #bbbbbb } /* Text.Whitespace */\n",
-       ".output_html .mb { color: #666666 } /* Literal.Number.Bin */\n",
-       ".output_html .mf { color: #666666 } /* Literal.Number.Float */\n",
-       ".output_html .mh { color: #666666 } /* Literal.Number.Hex */\n",
-       ".output_html .mi { color: #666666 } /* Literal.Number.Integer */\n",
-       ".output_html .mo { color: #666666 } /* Literal.Number.Oct */\n",
-       ".output_html .sa { color: #BA2121 } /* Literal.String.Affix */\n",
-       ".output_html .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
-       ".output_html .sc { color: #BA2121 } /* Literal.String.Char */\n",
-       ".output_html .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
-       ".output_html .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
-       ".output_html .s2 { color: #BA2121 } /* Literal.String.Double */\n",
-       ".output_html .se { color: #AA5D1F; font-weight: bold } /* Literal.String.Escape */\n",
-       ".output_html .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
-       ".output_html .si { color: #A45A77; font-weight: bold } /* Literal.String.Interpol */\n",
-       ".output_html .sx { color: #008000 } /* Literal.String.Other */\n",
-       ".output_html .sr { color: #A45A77 } /* Literal.String.Regex */\n",
-       ".output_html .s1 { color: #BA2121 } /* Literal.String.Single */\n",
-       ".output_html .ss { color: #19177C } /* Literal.String.Symbol */\n",
-       ".output_html .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       ".output_html .fm { color: #0000FF } /* Name.Function.Magic */\n",
-       ".output_html .vc { color: #19177C } /* Name.Variable.Class */\n",
-       ".output_html .vg { color: #19177C } /* Name.Variable.Global */\n",
-       ".output_html .vi { color: #19177C } /* Name.Variable.Instance */\n",
-       ".output_html .vm { color: #19177C } /* Name.Variable.Magic */\n",
-       ".output_html .il { color: #666666 } /* Literal.Number.Integer.Long */</style><div class=\"highlight\"><pre><span></span><span class=\"c1\">### BEGIN</span>\n",
-       "<span class=\"k\">def</span> <span class=\"nf\">_test_cell_</span><span class=\"p\">():</span>\n",
-       "\t<span class=\"c1\"># %%testcell</span>\n",
-       "\t<span class=\"k\">return</span> <span class=\"s1\">&#39;using </span><span class=\"si\">%%</span><span class=\"s1\">testcell updates the last executed expression result &quot;_&quot;&#39;</span> <span class=\"c1\"># %%testcell</span>\n",
-       "<span class=\"k\">try</span><span class=\"p\">:</span>\n",
-       "\t<span class=\"n\">_</span> <span class=\"o\">=</span> <span class=\"n\">_test_cell_</span><span class=\"p\">()</span>\n",
-       "<span class=\"k\">finally</span><span class=\"p\">:</span>\n",
-       "\t<span class=\"k\">del</span> <span class=\"n\">_test_cell_</span>\n",
-       "<span class=\"n\">_</span> <span class=\"c1\"># This will be added to global scope</span>\n",
-       "<span class=\"c1\">### END</span>\n",
-       "</pre></div>\n"
-      ],
-      "text/latex": [
-       "\\begin{Verbatim}[commandchars=\\\\\\{\\}]\n",
-       "\\PY{c+c1}{\\PYZsh{}\\PYZsh{}\\PYZsh{} BEGIN}\n",
-       "\\PY{k}{def} \\PY{n+nf}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\\PY{p}{(}\\PY{p}{)}\\PY{p}{:}\n",
-       "\t\\PY{c+c1}{\\PYZsh{} \\PYZpc{}\\PYZpc{}testcell}\n",
-       "\t\\PY{k}{return} \\PY{l+s+s1}{\\PYZsq{}}\\PY{l+s+s1}{using }\\PY{l+s+si}{\\PYZpc{}\\PYZpc{}}\\PY{l+s+s1}{testcell updates the last executed expression result }\\PY{l+s+s1}{\\PYZdq{}}\\PY{l+s+s1}{\\PYZus{}}\\PY{l+s+s1}{\\PYZdq{}}\\PY{l+s+s1}{\\PYZsq{}} \\PY{c+c1}{\\PYZsh{} \\PYZpc{}\\PYZpc{}testcell}\n",
-       "\\PY{k}{try}\\PY{p}{:}\n",
-       "\t\\PY{n}{\\PYZus{}} \\PY{o}{=} \\PY{n}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\\PY{p}{(}\\PY{p}{)}\n",
-       "\\PY{k}{finally}\\PY{p}{:}\n",
-       "\t\\PY{k}{del} \\PY{n}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\n",
-       "\\PY{n}{\\PYZus{}} \\PY{c+c1}{\\PYZsh{} This will be added to global scope}\n",
-       "\\PY{c+c1}{\\PYZsh{}\\PYZsh{}\\PYZsh{} END}\n",
-       "\\end{Verbatim}\n"
+      "text/markdown": [
+       "```python\n",
+       "### BEGIN\n",
+       "def _test_cell_():\n",
+       "\t# %%testcell verbose\n",
+       "\treturn 'using %%testcell updates the last executed expression result \"_\"' # %%testcell\n",
+       "try:\n",
+       "\t_ = _test_cell_()\n",
+       "finally:\n",
+       "\tdel _test_cell_\n",
+       "_ # This will be added to global scope\n",
+       "### END\n",
+       "```"
       ],
       "text/plain": [
-       "\n",
        "### BEGIN\n",
        "def _test_cell_():\n",
-       "\t# %%testcell\n",
+       "\t# %%testcell verbose\n",
        "\treturn 'using %%testcell updates the last executed expression result \"_\"' # %%testcell\n",
        "try:\n",
        "\t_ = _test_cell_()\n",
@@ -1348,7 +1385,7 @@
    ],
    "source": [
     "%%testcell verbose\n",
-    "# %%testcell\n",
+    "# %%testcell verbose\n",
     "'using %%testcell updates the last executed expression result \"_\"'"
    ]
   },
@@ -1375,108 +1412,21 @@
    "outputs": [
     {
      "data": {
-      "text/html": [
-       "<style>pre { line-height: 125%; }\n",
-       "td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
-       "span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
-       "td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
-       "span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
-       ".output_html .hll { background-color: #ffffcc }\n",
-       ".output_html { background: #f8f8f8; }\n",
-       ".output_html .c { color: #3D7B7B; font-style: italic } /* Comment */\n",
-       ".output_html .err { border: 1px solid #FF0000 } /* Error */\n",
-       ".output_html .k { color: #008000; font-weight: bold } /* Keyword */\n",
-       ".output_html .o { color: #666666 } /* Operator */\n",
-       ".output_html .ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */\n",
-       ".output_html .cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */\n",
-       ".output_html .cp { color: #9C6500 } /* Comment.Preproc */\n",
-       ".output_html .cpf { color: #3D7B7B; font-style: italic } /* Comment.PreprocFile */\n",
-       ".output_html .c1 { color: #3D7B7B; font-style: italic } /* Comment.Single */\n",
-       ".output_html .cs { color: #3D7B7B; font-style: italic } /* Comment.Special */\n",
-       ".output_html .gd { color: #A00000 } /* Generic.Deleted */\n",
-       ".output_html .ge { font-style: italic } /* Generic.Emph */\n",
-       ".output_html .gr { color: #E40000 } /* Generic.Error */\n",
-       ".output_html .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
-       ".output_html .gi { color: #008400 } /* Generic.Inserted */\n",
-       ".output_html .go { color: #717171 } /* Generic.Output */\n",
-       ".output_html .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
-       ".output_html .gs { font-weight: bold } /* Generic.Strong */\n",
-       ".output_html .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       ".output_html .gt { color: #0044DD } /* Generic.Traceback */\n",
-       ".output_html .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
-       ".output_html .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
-       ".output_html .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
-       ".output_html .kp { color: #008000 } /* Keyword.Pseudo */\n",
-       ".output_html .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
-       ".output_html .kt { color: #B00040 } /* Keyword.Type */\n",
-       ".output_html .m { color: #666666 } /* Literal.Number */\n",
-       ".output_html .s { color: #BA2121 } /* Literal.String */\n",
-       ".output_html .na { color: #687822 } /* Name.Attribute */\n",
-       ".output_html .nb { color: #008000 } /* Name.Builtin */\n",
-       ".output_html .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       ".output_html .no { color: #880000 } /* Name.Constant */\n",
-       ".output_html .nd { color: #AA22FF } /* Name.Decorator */\n",
-       ".output_html .ni { color: #717171; font-weight: bold } /* Name.Entity */\n",
-       ".output_html .ne { color: #CB3F38; font-weight: bold } /* Name.Exception */\n",
-       ".output_html .nf { color: #0000FF } /* Name.Function */\n",
-       ".output_html .nl { color: #767600 } /* Name.Label */\n",
-       ".output_html .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
-       ".output_html .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
-       ".output_html .nv { color: #19177C } /* Name.Variable */\n",
-       ".output_html .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       ".output_html .w { color: #bbbbbb } /* Text.Whitespace */\n",
-       ".output_html .mb { color: #666666 } /* Literal.Number.Bin */\n",
-       ".output_html .mf { color: #666666 } /* Literal.Number.Float */\n",
-       ".output_html .mh { color: #666666 } /* Literal.Number.Hex */\n",
-       ".output_html .mi { color: #666666 } /* Literal.Number.Integer */\n",
-       ".output_html .mo { color: #666666 } /* Literal.Number.Oct */\n",
-       ".output_html .sa { color: #BA2121 } /* Literal.String.Affix */\n",
-       ".output_html .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
-       ".output_html .sc { color: #BA2121 } /* Literal.String.Char */\n",
-       ".output_html .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
-       ".output_html .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
-       ".output_html .s2 { color: #BA2121 } /* Literal.String.Double */\n",
-       ".output_html .se { color: #AA5D1F; font-weight: bold } /* Literal.String.Escape */\n",
-       ".output_html .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
-       ".output_html .si { color: #A45A77; font-weight: bold } /* Literal.String.Interpol */\n",
-       ".output_html .sx { color: #008000 } /* Literal.String.Other */\n",
-       ".output_html .sr { color: #A45A77 } /* Literal.String.Regex */\n",
-       ".output_html .s1 { color: #BA2121 } /* Literal.String.Single */\n",
-       ".output_html .ss { color: #19177C } /* Literal.String.Symbol */\n",
-       ".output_html .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       ".output_html .fm { color: #0000FF } /* Name.Function.Magic */\n",
-       ".output_html .vc { color: #19177C } /* Name.Variable.Class */\n",
-       ".output_html .vg { color: #19177C } /* Name.Variable.Global */\n",
-       ".output_html .vi { color: #19177C } /* Name.Variable.Instance */\n",
-       ".output_html .vm { color: #19177C } /* Name.Variable.Magic */\n",
-       ".output_html .il { color: #666666 } /* Literal.Number.Integer.Long */</style><div class=\"highlight\"><pre><span></span><span class=\"c1\">### BEGIN</span>\n",
-       "<span class=\"k\">def</span> <span class=\"nf\">_test_cell_</span><span class=\"p\">():</span>\n",
-       "\t<span class=\"c1\"># %%testcelln</span>\n",
-       "\t<span class=\"k\">return</span> <span class=\"s1\">&#39;</span><span class=\"si\">%%</span><span class=\"s1\">testcelln does not change &quot;_&quot;&#39;</span> <span class=\"c1\"># %%testcell</span>\n",
-       "<span class=\"k\">try</span><span class=\"p\">:</span>\n",
-       "\t<span class=\"n\">_</span> <span class=\"o\">=</span> <span class=\"n\">_test_cell_</span><span class=\"p\">()</span>\n",
-       "<span class=\"k\">finally</span><span class=\"p\">:</span>\n",
-       "\t<span class=\"k\">del</span> <span class=\"n\">_test_cell_</span>\n",
-       "<span class=\"k\">if</span> <span class=\"n\">_</span> <span class=\"ow\">is</span> <span class=\"ow\">not</span> <span class=\"kc\">None</span><span class=\"p\">:</span> <span class=\"n\">display</span><span class=\"p\">(</span><span class=\"n\">_</span><span class=\"p\">)</span>\n",
-       "<span class=\"c1\">### END</span>\n",
-       "</pre></div>\n"
-      ],
-      "text/latex": [
-       "\\begin{Verbatim}[commandchars=\\\\\\{\\}]\n",
-       "\\PY{c+c1}{\\PYZsh{}\\PYZsh{}\\PYZsh{} BEGIN}\n",
-       "\\PY{k}{def} \\PY{n+nf}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\\PY{p}{(}\\PY{p}{)}\\PY{p}{:}\n",
-       "\t\\PY{c+c1}{\\PYZsh{} \\PYZpc{}\\PYZpc{}testcelln}\n",
-       "\t\\PY{k}{return} \\PY{l+s+s1}{\\PYZsq{}}\\PY{l+s+si}{\\PYZpc{}\\PYZpc{}}\\PY{l+s+s1}{testcelln does not change }\\PY{l+s+s1}{\\PYZdq{}}\\PY{l+s+s1}{\\PYZus{}}\\PY{l+s+s1}{\\PYZdq{}}\\PY{l+s+s1}{\\PYZsq{}} \\PY{c+c1}{\\PYZsh{} \\PYZpc{}\\PYZpc{}testcell}\n",
-       "\\PY{k}{try}\\PY{p}{:}\n",
-       "\t\\PY{n}{\\PYZus{}} \\PY{o}{=} \\PY{n}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\\PY{p}{(}\\PY{p}{)}\n",
-       "\\PY{k}{finally}\\PY{p}{:}\n",
-       "\t\\PY{k}{del} \\PY{n}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\n",
-       "\\PY{k}{if} \\PY{n}{\\PYZus{}} \\PY{o+ow}{is} \\PY{o+ow}{not} \\PY{k+kc}{None}\\PY{p}{:} \\PY{n}{display}\\PY{p}{(}\\PY{n}{\\PYZus{}}\\PY{p}{)}\n",
-       "\\PY{c+c1}{\\PYZsh{}\\PYZsh{}\\PYZsh{} END}\n",
-       "\\end{Verbatim}\n"
+      "text/markdown": [
+       "```python\n",
+       "### BEGIN\n",
+       "def _test_cell_():\n",
+       "\t# %%testcelln\n",
+       "\treturn '%%testcelln does not change \"_\"' # %%testcell\n",
+       "try:\n",
+       "\t_ = _test_cell_()\n",
+       "finally:\n",
+       "\tdel _test_cell_\n",
+       "if _ is not None: display(_)\n",
+       "### END\n",
+       "```"
       ],
       "text/plain": [
-       "\n",
        "### BEGIN\n",
        "def _test_cell_():\n",
        "\t# %%testcelln\n",
@@ -1524,6 +1474,235 @@
     "`%%testcelln` instead includes the `noreturn` option that avoids modifying last command execution `_`."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## inout syntax\n",
+    "\n",
+    "This is the most advanced option and is meant to enable selectively passing data in and out the context of testecell.\n",
+    "It's based on the **cell as function idea**, with the ability not only to input and output data but also symbols."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define some stuff in the global space\n",
+    "def my_global_func(x): return x*2\n",
+    "my_global_variable = 123"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Selectively add objects from global state\n",
+    "\n",
+    "This is useful when we're developing something in isolation, but we need access to libraries, constants or other objects from the main scope."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "dict_keys(['my_global_func', 'my_global_variable', '__builtins__'])\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%testcelln (my_global_func,my_global_variable)\n",
+    "print(globals().keys())\n",
+    "\n",
+    "# We can now access only to these two additional functions\n",
+    "assert my_global_variable==123\n",
+    "assert my_global_func(1)==2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Selectively pushing changes to global state \n",
+    "In this case we're "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert 'kkk' not in globals().keys()\n",
+    "assert 'fff' not in globals().keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "```python\n",
+       "### BEGIN\n",
+       "def _test_cell_():\n",
+       "\tglobal kkk\n",
+       "\tglobal fff\n",
+       "\t\n",
+       "\tkkk = 'this is a global variable created inside testcelln cell'\n",
+       "\tdef fff(): \n",
+       "\t    # this is a global function created inside testcelln cell\n",
+       "\t    return my_global_variable # we use a global variable that should not be accessible\n",
+       "\t\n",
+       "\treturn fff() # %%testcell\n",
+       "try:\n",
+       "\t_ = _test_cell_()\n",
+       "finally:\n",
+       "\tdel _test_cell_\n",
+       "if _ is not None: display(_)\n",
+       "### END\n",
+       "```"
+      ],
+      "text/plain": [
+       "### BEGIN\n",
+       "def _test_cell_():\n",
+       "\tglobal kkk\n",
+       "\tglobal fff\n",
+       "\t\n",
+       "\tkkk = 'this is a global variable created inside testcelln cell'\n",
+       "\tdef fff(): \n",
+       "\t    # this is a global function created inside testcelln cell\n",
+       "\t    return my_global_variable # we use a global variable that should not be accessible\n",
+       "\t\n",
+       "\treturn fff() # %%testcell\n",
+       "try:\n",
+       "\t_ = _test_cell_()\n",
+       "finally:\n",
+       "\tdel _test_cell_\n",
+       "if _ is not None: display(_)\n",
+       "### END"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "123"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "```python\n",
+       "### GLOBALS UPDATE CODE:\n",
+       "global kkk; kkk=locals()[\"kkk\"]\n",
+       "global fff; fff=locals()[\"fff\"]\n",
+       "###\n",
+       "```"
+      ],
+      "text/plain": [
+       "### GLOBALS UPDATE CODE:\n",
+       "global kkk; kkk=locals()[\"kkk\"]\n",
+       "global fff; fff=locals()[\"fff\"]\n",
+       "###"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%testcelln (my_global_variable)->(kkk,fff) debug\n",
+    "\n",
+    "kkk = 'this is a global variable created inside testcelln cell'\n",
+    "def fff(): \n",
+    "    # this is a global function created inside testcelln cell\n",
+    "    return my_global_variable # we use a global variable that should not be accessible\n",
+    "\n",
+    "fff()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert kkk=='this is a global variable created inside testcelln cell'\n",
+    "assert fff()==123"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# cleanup\n",
+    "del kkk\n",
+    "del fff"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This last example is about only returning data:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert 'fff' not in globals().keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%testcelln ->(fff)\n",
+    "def a(): return 7\n",
+    "def fff(): return a()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_eq(fff(),7)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# cleanup\n",
+    "del fff"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
diff --git a/nbs/index.ipynb b/nbs/index.ipynb
index 58c9e1d..feb5087 100644
--- a/nbs/index.ipynb
+++ b/nbs/index.ipynb
@@ -21,30 +21,22 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "**TL;DR**: `%%testcell` prevents your testing cells from affecting the global namespace.\n",
+    "One good thing about working in Jupyter notebooks is that they make it easy to quickly test a bit of code by evaluating it in notebook cell. But one bad thing is that the _definitions_ resulting from that evaluation hang around afterwards, when all you wanted was just to test that one bit of code. \n",
+    " \n",
+    "`%%testcell` is a simple simple solution to that problem.  It lets you execute notebook cells in isolation. Test code, try snippets, and experiment freely: no variables, functions, classes, or imports are left behind. This helps to keep your namespace clean, so that leftover symbols do not confuse later work.\n",
     "\n",
-    "The Python cell magic `%%testcell` executes a cell without *polluting* the notebook's global namespace. This is useful whenever you want to test your code without having any of the local variables escape that cell.\n",
+    "**WARNING:** this doesn't protect you from *the side effects of your code* like deleting a file or mutating the state of a global variable.\n",
     "\n",
-    "What's happening under the hood is that your cell code, before being executed, is wrapped in a temporary function that will be deleted after execution. To give you the feeling of *seamless integration* the last statement is optionally returned like it happens in a normal cell.\n",
-    "\n",
-    "**WARNING:** this don't protect you from *the side effects of your code* like deleting a file or mutating the state of a global variable.\n",
-    "\n",
-    "[![](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/artste/testcell/blob/main/demo/testcell_demo.ipynb) \n",
-    "\n",
-    "[![](https://kaggle.com/static/images/open-in-kaggle.svg)](https://www.kaggle.com/artste/introducing-testcell)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Install"
+    "[![](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/artste/testcell/blob/main/demo/testcell_demo.ipynb)  [![](https://kaggle.com/static/images/open-in-kaggle.svg)](https://www.kaggle.com/artste/introducing-testcell) [![](https://modal-cdn.com/open-in-modal.svg)](https://modal.com/notebooks/new/https://github.com/artste/testcell/blob/main/demo/testcell_demo.ipynb)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
+    "## Install\n",
+    "Lightweight and reliable: `%%testcell` depends only on IPython and works in all major notebook environments including Jupyter, Colab, Kaggle, Modal, Solveit, and the IPython console.\n",
+    "\n",
     "```sh\n",
     "pip install testcell\n",
     "```"
@@ -54,24 +46,18 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## How to use"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "just import it with `import testcell` and then use the `%%testcell` cell magic."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
+    "## Quick Start\n",
+    "\n",
+    "First import `testcell`:\n",
+    "```python\n",
+    "import testcell\n",
+    "```\n",
+    "\n",
+    "Then use it:\n",
     "```python\n",
     "%%testcell\n",
-    "a = \"'a' is not polluting global scope\"\n",
-    "a\n",
+    "temp_var = \"This won't pollute namespace\"\n",
+    "temp_var\n",
     "```"
    ]
   },
@@ -83,7 +69,7 @@
     {
      "data": {
       "text/plain": [
-       "\"'a' is not polluting global scope\""
+       "\"This won't pollute namespace\""
       ]
      },
      "execution_count": null,
@@ -94,36 +80,34 @@
    "source": [
     "%%testcell\n",
     "#| echo: false\n",
-    "a = \"'a' is not polluting global scope\"\n",
-    "a"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "assert 'a' not in locals()"
+    "temp_var = \"This won't pollute namespace\"\n",
+    "temp_var"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "What is happening under the hood is that `%%testcell` wraps your cell's code with a function, execute it and then deletes it. Adding the `verbose` keywork will print which code will be executed.\n",
-    "\n",
-    "NOTE: The actual cell code is enclosed within `BEGIN` and `END` comment blocks for improved readability."
+    "```python\n",
+    "# temp_var doesn't exist — it was only defined inside the test cell\n",
+    "temp_var  # NameError: name 'temp_var' is not defined\n",
+    "```"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
+    "## How it works\n",
+    "\n",
+    "Import `testcell` and use the `%%testcell` magic at the top of any cell. Under the hood, your code is wrapped in a temporary function that executes and then deletes itself.\n",
+    "\n",
+    "Use `verbose` to see the generated wrapper code:\n",
+    "\n",
     "```python\n",
     "%%testcell verbose\n",
-    "a = \"'a' is not polluting global scope\"\n",
-    "a\n",
+    "result = \"isolated execution\"\n",
+    "result\n",
     "```"
    ]
   },
@@ -134,115 +118,27 @@
    "outputs": [
     {
      "data": {
-      "text/html": [
-       "<style>pre { line-height: 125%; }\n",
-       "td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
-       "span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
-       "td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
-       "span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
-       ".output_html .hll { background-color: #ffffcc }\n",
-       ".output_html { background: #f8f8f8; }\n",
-       ".output_html .c { color: #3D7B7B; font-style: italic } /* Comment */\n",
-       ".output_html .err { border: 1px solid #FF0000 } /* Error */\n",
-       ".output_html .k { color: #008000; font-weight: bold } /* Keyword */\n",
-       ".output_html .o { color: #666666 } /* Operator */\n",
-       ".output_html .ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */\n",
-       ".output_html .cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */\n",
-       ".output_html .cp { color: #9C6500 } /* Comment.Preproc */\n",
-       ".output_html .cpf { color: #3D7B7B; font-style: italic } /* Comment.PreprocFile */\n",
-       ".output_html .c1 { color: #3D7B7B; font-style: italic } /* Comment.Single */\n",
-       ".output_html .cs { color: #3D7B7B; font-style: italic } /* Comment.Special */\n",
-       ".output_html .gd { color: #A00000 } /* Generic.Deleted */\n",
-       ".output_html .ge { font-style: italic } /* Generic.Emph */\n",
-       ".output_html .gr { color: #E40000 } /* Generic.Error */\n",
-       ".output_html .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
-       ".output_html .gi { color: #008400 } /* Generic.Inserted */\n",
-       ".output_html .go { color: #717171 } /* Generic.Output */\n",
-       ".output_html .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
-       ".output_html .gs { font-weight: bold } /* Generic.Strong */\n",
-       ".output_html .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       ".output_html .gt { color: #0044DD } /* Generic.Traceback */\n",
-       ".output_html .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
-       ".output_html .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
-       ".output_html .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
-       ".output_html .kp { color: #008000 } /* Keyword.Pseudo */\n",
-       ".output_html .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
-       ".output_html .kt { color: #B00040 } /* Keyword.Type */\n",
-       ".output_html .m { color: #666666 } /* Literal.Number */\n",
-       ".output_html .s { color: #BA2121 } /* Literal.String */\n",
-       ".output_html .na { color: #687822 } /* Name.Attribute */\n",
-       ".output_html .nb { color: #008000 } /* Name.Builtin */\n",
-       ".output_html .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       ".output_html .no { color: #880000 } /* Name.Constant */\n",
-       ".output_html .nd { color: #AA22FF } /* Name.Decorator */\n",
-       ".output_html .ni { color: #717171; font-weight: bold } /* Name.Entity */\n",
-       ".output_html .ne { color: #CB3F38; font-weight: bold } /* Name.Exception */\n",
-       ".output_html .nf { color: #0000FF } /* Name.Function */\n",
-       ".output_html .nl { color: #767600 } /* Name.Label */\n",
-       ".output_html .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
-       ".output_html .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
-       ".output_html .nv { color: #19177C } /* Name.Variable */\n",
-       ".output_html .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       ".output_html .w { color: #bbbbbb } /* Text.Whitespace */\n",
-       ".output_html .mb { color: #666666 } /* Literal.Number.Bin */\n",
-       ".output_html .mf { color: #666666 } /* Literal.Number.Float */\n",
-       ".output_html .mh { color: #666666 } /* Literal.Number.Hex */\n",
-       ".output_html .mi { color: #666666 } /* Literal.Number.Integer */\n",
-       ".output_html .mo { color: #666666 } /* Literal.Number.Oct */\n",
-       ".output_html .sa { color: #BA2121 } /* Literal.String.Affix */\n",
-       ".output_html .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
-       ".output_html .sc { color: #BA2121 } /* Literal.String.Char */\n",
-       ".output_html .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
-       ".output_html .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
-       ".output_html .s2 { color: #BA2121 } /* Literal.String.Double */\n",
-       ".output_html .se { color: #AA5D1F; font-weight: bold } /* Literal.String.Escape */\n",
-       ".output_html .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
-       ".output_html .si { color: #A45A77; font-weight: bold } /* Literal.String.Interpol */\n",
-       ".output_html .sx { color: #008000 } /* Literal.String.Other */\n",
-       ".output_html .sr { color: #A45A77 } /* Literal.String.Regex */\n",
-       ".output_html .s1 { color: #BA2121 } /* Literal.String.Single */\n",
-       ".output_html .ss { color: #19177C } /* Literal.String.Symbol */\n",
-       ".output_html .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       ".output_html .fm { color: #0000FF } /* Name.Function.Magic */\n",
-       ".output_html .vc { color: #19177C } /* Name.Variable.Class */\n",
-       ".output_html .vg { color: #19177C } /* Name.Variable.Global */\n",
-       ".output_html .vi { color: #19177C } /* Name.Variable.Instance */\n",
-       ".output_html .vm { color: #19177C } /* Name.Variable.Magic */\n",
-       ".output_html .il { color: #666666 } /* Literal.Number.Integer.Long */</style><div class=\"highlight\"><pre><span></span><span class=\"c1\">### BEGIN</span>\n",
-       "<span class=\"k\">def</span> <span class=\"nf\">_test_cell_</span><span class=\"p\">():</span>\n",
-       "\t<span class=\"c1\">#| echo: false</span>\n",
-       "\t<span class=\"n\">a</span> <span class=\"o\">=</span> <span class=\"s2\">&quot;&#39;a&#39; is not polluting global scope&quot;</span>\n",
-       "\t<span class=\"k\">return</span> <span class=\"n\">a</span> <span class=\"c1\"># %%testcell</span>\n",
-       "<span class=\"k\">try</span><span class=\"p\">:</span>\n",
-       "\t<span class=\"n\">_</span> <span class=\"o\">=</span> <span class=\"n\">_test_cell_</span><span class=\"p\">()</span>\n",
-       "<span class=\"k\">finally</span><span class=\"p\">:</span>\n",
-       "\t<span class=\"k\">del</span> <span class=\"n\">_test_cell_</span>\n",
-       "<span class=\"n\">_</span> <span class=\"c1\"># This will be added to global scope</span>\n",
-       "<span class=\"c1\">### END</span>\n",
-       "</pre></div>\n"
-      ],
-      "text/latex": [
-       "\\begin{Verbatim}[commandchars=\\\\\\{\\}]\n",
-       "\\PY{c+c1}{\\PYZsh{}\\PYZsh{}\\PYZsh{} BEGIN}\n",
-       "\\PY{k}{def} \\PY{n+nf}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\\PY{p}{(}\\PY{p}{)}\\PY{p}{:}\n",
-       "\t\\PY{c+c1}{\\PYZsh{}| echo: false}\n",
-       "\t\\PY{n}{a} \\PY{o}{=} \\PY{l+s+s2}{\\PYZdq{}}\\PY{l+s+s2}{\\PYZsq{}}\\PY{l+s+s2}{a}\\PY{l+s+s2}{\\PYZsq{}}\\PY{l+s+s2}{ is not polluting global scope}\\PY{l+s+s2}{\\PYZdq{}}\n",
-       "\t\\PY{k}{return} \\PY{n}{a} \\PY{c+c1}{\\PYZsh{} \\PYZpc{}\\PYZpc{}testcell}\n",
-       "\\PY{k}{try}\\PY{p}{:}\n",
-       "\t\\PY{n}{\\PYZus{}} \\PY{o}{=} \\PY{n}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\\PY{p}{(}\\PY{p}{)}\n",
-       "\\PY{k}{finally}\\PY{p}{:}\n",
-       "\t\\PY{k}{del} \\PY{n}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\n",
-       "\\PY{n}{\\PYZus{}} \\PY{c+c1}{\\PYZsh{} This will be added to global scope}\n",
-       "\\PY{c+c1}{\\PYZsh{}\\PYZsh{}\\PYZsh{} END}\n",
-       "\\end{Verbatim}\n"
+      "text/markdown": [
+       "```python\n",
+       "### BEGIN\n",
+       "def _test_cell_():\n",
+       "\t#| echo: false\n",
+       "\tresult = \"isolated execution\"\n",
+       "\treturn result # %%testcell\n",
+       "try:\n",
+       "\t_ = _test_cell_()\n",
+       "finally:\n",
+       "\tdel _test_cell_\n",
+       "_ # This will be added to global scope\n",
+       "### END\n",
+       "```"
       ],
       "text/plain": [
-       "\n",
        "### BEGIN\n",
        "def _test_cell_():\n",
        "\t#| echo: false\n",
-       "\ta = \"'a' is not polluting global scope\"\n",
-       "\treturn a # %%testcell\n",
+       "\tresult = \"isolated execution\"\n",
+       "\treturn result # %%testcell\n",
        "try:\n",
        "\t_ = _test_cell_()\n",
        "finally:\n",
@@ -257,7 +153,7 @@
     {
      "data": {
       "text/plain": [
-       "\"'a' is not polluting global scope\""
+       "'isolated execution'"
       ]
      },
      "execution_count": null,
@@ -268,25 +164,22 @@
    "source": [
     "%%testcell verbose\n",
     "#| echo: false\n",
-    "a = \"'a' is not polluting global scope\"\n",
-    "a"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "If you're just interested in seeing what will be executed, but actually not executing it, you ca use `dryrun` option:"
+    "result = \"isolated execution\"\n",
+    "result"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
+    "## Suppressing output\n",
+    "\n",
+    "Like normal Jupyter cells, add a semicolon `;` to the last statement to suppress display:\n",
+    "\n",
     "```python\n",
-    "%%testcell dryrun\n",
-    "a = \"'a' is not polluting global scope\"\n",
-    "a\n",
+    "%%testcell\n",
+    "calculation = 42 * 2\n",
+    "calculation;\n",
     "```"
    ]
   },
@@ -294,152 +187,34 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<style>pre { line-height: 125%; }\n",
-       "td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
-       "span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
-       "td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
-       "span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
-       ".output_html .hll { background-color: #ffffcc }\n",
-       ".output_html { background: #f8f8f8; }\n",
-       ".output_html .c { color: #3D7B7B; font-style: italic } /* Comment */\n",
-       ".output_html .err { border: 1px solid #FF0000 } /* Error */\n",
-       ".output_html .k { color: #008000; font-weight: bold } /* Keyword */\n",
-       ".output_html .o { color: #666666 } /* Operator */\n",
-       ".output_html .ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */\n",
-       ".output_html .cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */\n",
-       ".output_html .cp { color: #9C6500 } /* Comment.Preproc */\n",
-       ".output_html .cpf { color: #3D7B7B; font-style: italic } /* Comment.PreprocFile */\n",
-       ".output_html .c1 { color: #3D7B7B; font-style: italic } /* Comment.Single */\n",
-       ".output_html .cs { color: #3D7B7B; font-style: italic } /* Comment.Special */\n",
-       ".output_html .gd { color: #A00000 } /* Generic.Deleted */\n",
-       ".output_html .ge { font-style: italic } /* Generic.Emph */\n",
-       ".output_html .gr { color: #E40000 } /* Generic.Error */\n",
-       ".output_html .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
-       ".output_html .gi { color: #008400 } /* Generic.Inserted */\n",
-       ".output_html .go { color: #717171 } /* Generic.Output */\n",
-       ".output_html .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
-       ".output_html .gs { font-weight: bold } /* Generic.Strong */\n",
-       ".output_html .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       ".output_html .gt { color: #0044DD } /* Generic.Traceback */\n",
-       ".output_html .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
-       ".output_html .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
-       ".output_html .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
-       ".output_html .kp { color: #008000 } /* Keyword.Pseudo */\n",
-       ".output_html .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
-       ".output_html .kt { color: #B00040 } /* Keyword.Type */\n",
-       ".output_html .m { color: #666666 } /* Literal.Number */\n",
-       ".output_html .s { color: #BA2121 } /* Literal.String */\n",
-       ".output_html .na { color: #687822 } /* Name.Attribute */\n",
-       ".output_html .nb { color: #008000 } /* Name.Builtin */\n",
-       ".output_html .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       ".output_html .no { color: #880000 } /* Name.Constant */\n",
-       ".output_html .nd { color: #AA22FF } /* Name.Decorator */\n",
-       ".output_html .ni { color: #717171; font-weight: bold } /* Name.Entity */\n",
-       ".output_html .ne { color: #CB3F38; font-weight: bold } /* Name.Exception */\n",
-       ".output_html .nf { color: #0000FF } /* Name.Function */\n",
-       ".output_html .nl { color: #767600 } /* Name.Label */\n",
-       ".output_html .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
-       ".output_html .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
-       ".output_html .nv { color: #19177C } /* Name.Variable */\n",
-       ".output_html .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       ".output_html .w { color: #bbbbbb } /* Text.Whitespace */\n",
-       ".output_html .mb { color: #666666 } /* Literal.Number.Bin */\n",
-       ".output_html .mf { color: #666666 } /* Literal.Number.Float */\n",
-       ".output_html .mh { color: #666666 } /* Literal.Number.Hex */\n",
-       ".output_html .mi { color: #666666 } /* Literal.Number.Integer */\n",
-       ".output_html .mo { color: #666666 } /* Literal.Number.Oct */\n",
-       ".output_html .sa { color: #BA2121 } /* Literal.String.Affix */\n",
-       ".output_html .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
-       ".output_html .sc { color: #BA2121 } /* Literal.String.Char */\n",
-       ".output_html .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
-       ".output_html .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
-       ".output_html .s2 { color: #BA2121 } /* Literal.String.Double */\n",
-       ".output_html .se { color: #AA5D1F; font-weight: bold } /* Literal.String.Escape */\n",
-       ".output_html .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
-       ".output_html .si { color: #A45A77; font-weight: bold } /* Literal.String.Interpol */\n",
-       ".output_html .sx { color: #008000 } /* Literal.String.Other */\n",
-       ".output_html .sr { color: #A45A77 } /* Literal.String.Regex */\n",
-       ".output_html .s1 { color: #BA2121 } /* Literal.String.Single */\n",
-       ".output_html .ss { color: #19177C } /* Literal.String.Symbol */\n",
-       ".output_html .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       ".output_html .fm { color: #0000FF } /* Name.Function.Magic */\n",
-       ".output_html .vc { color: #19177C } /* Name.Variable.Class */\n",
-       ".output_html .vg { color: #19177C } /* Name.Variable.Global */\n",
-       ".output_html .vi { color: #19177C } /* Name.Variable.Instance */\n",
-       ".output_html .vm { color: #19177C } /* Name.Variable.Magic */\n",
-       ".output_html .il { color: #666666 } /* Literal.Number.Integer.Long */</style><div class=\"highlight\"><pre><span></span><span class=\"c1\">### BEGIN</span>\n",
-       "<span class=\"k\">def</span> <span class=\"nf\">_test_cell_</span><span class=\"p\">():</span>\n",
-       "\t<span class=\"c1\">#| echo: false</span>\n",
-       "\t<span class=\"n\">a</span> <span class=\"o\">=</span> <span class=\"s2\">&quot;&#39;a&#39; is not polluting global scope&quot;</span>\n",
-       "\t<span class=\"k\">return</span> <span class=\"n\">a</span> <span class=\"c1\"># %%testcell</span>\n",
-       "<span class=\"k\">try</span><span class=\"p\">:</span>\n",
-       "\t<span class=\"n\">_</span> <span class=\"o\">=</span> <span class=\"n\">_test_cell_</span><span class=\"p\">()</span>\n",
-       "<span class=\"k\">finally</span><span class=\"p\">:</span>\n",
-       "\t<span class=\"k\">del</span> <span class=\"n\">_test_cell_</span>\n",
-       "<span class=\"k\">if</span> <span class=\"n\">_</span> <span class=\"ow\">is</span> <span class=\"ow\">not</span> <span class=\"kc\">None</span><span class=\"p\">:</span> <span class=\"n\">display</span><span class=\"p\">(</span><span class=\"n\">_</span><span class=\"p\">)</span>\n",
-       "<span class=\"c1\">### END</span>\n",
-       "</pre></div>\n"
-      ],
-      "text/latex": [
-       "\\begin{Verbatim}[commandchars=\\\\\\{\\}]\n",
-       "\\PY{c+c1}{\\PYZsh{}\\PYZsh{}\\PYZsh{} BEGIN}\n",
-       "\\PY{k}{def} \\PY{n+nf}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\\PY{p}{(}\\PY{p}{)}\\PY{p}{:}\n",
-       "\t\\PY{c+c1}{\\PYZsh{}| echo: false}\n",
-       "\t\\PY{n}{a} \\PY{o}{=} \\PY{l+s+s2}{\\PYZdq{}}\\PY{l+s+s2}{\\PYZsq{}}\\PY{l+s+s2}{a}\\PY{l+s+s2}{\\PYZsq{}}\\PY{l+s+s2}{ is not polluting global scope}\\PY{l+s+s2}{\\PYZdq{}}\n",
-       "\t\\PY{k}{return} \\PY{n}{a} \\PY{c+c1}{\\PYZsh{} \\PYZpc{}\\PYZpc{}testcell}\n",
-       "\\PY{k}{try}\\PY{p}{:}\n",
-       "\t\\PY{n}{\\PYZus{}} \\PY{o}{=} \\PY{n}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\\PY{p}{(}\\PY{p}{)}\n",
-       "\\PY{k}{finally}\\PY{p}{:}\n",
-       "\t\\PY{k}{del} \\PY{n}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\n",
-       "\\PY{k}{if} \\PY{n}{\\PYZus{}} \\PY{o+ow}{is} \\PY{o+ow}{not} \\PY{k+kc}{None}\\PY{p}{:} \\PY{n}{display}\\PY{p}{(}\\PY{n}{\\PYZus{}}\\PY{p}{)}\n",
-       "\\PY{c+c1}{\\PYZsh{}\\PYZsh{}\\PYZsh{} END}\n",
-       "\\end{Verbatim}\n"
-      ],
-      "text/plain": [
-       "\n",
-       "### BEGIN\n",
-       "def _test_cell_():\n",
-       "\t#| echo: false\n",
-       "\ta = \"'a' is not polluting global scope\"\n",
-       "\treturn a # %%testcell\n",
-       "try:\n",
-       "\t_ = _test_cell_()\n",
-       "finally:\n",
-       "\tdel _test_cell_\n",
-       "if _ is not None: display(_)\n",
-       "### END"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "%%testcell dryrun\n",
+    "%%testcell\n",
     "#| echo: false\n",
-    "a = \"'a' is not polluting global scope\"\n",
-    "a"
+    "calculation = 42 * 2\n",
+    "calculation;"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "If you add a semicolon `;` at the end of your last statement no `return` statement is added and nothing is displayed like a normal jupyter cell."
+    "No output is displayed, and `calculation` still doesn't leak to globals."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
+    "## Skip execution\n",
+    "\n",
+    "Skip cells without deleting code using the `skip` command.\n",
+    "\n",
+    "**IMPORTANT**: This is especially useful in notebook environments like **Colab, Kaggle, and Modal** where you can't use Jupyter's \"Raw cell\" type to disable execution.\n",
+    "\n",
     "```python\n",
-    "%%testcell verbose\n",
-    "a = \"'a' is not polluting global scope\"\n",
-    "a;\n",
+    "%%testcell skip\n",
+    "raise ValueError('This will not execute')\n",
     "```"
    ]
   },
@@ -451,120 +226,14 @@
     {
      "data": {
       "text/html": [
-       "<style>pre { line-height: 125%; }\n",
-       "td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
-       "span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
-       "td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
-       "span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
-       ".output_html .hll { background-color: #ffffcc }\n",
-       ".output_html { background: #f8f8f8; }\n",
-       ".output_html .c { color: #3D7B7B; font-style: italic } /* Comment */\n",
-       ".output_html .err { border: 1px solid #FF0000 } /* Error */\n",
-       ".output_html .k { color: #008000; font-weight: bold } /* Keyword */\n",
-       ".output_html .o { color: #666666 } /* Operator */\n",
-       ".output_html .ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */\n",
-       ".output_html .cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */\n",
-       ".output_html .cp { color: #9C6500 } /* Comment.Preproc */\n",
-       ".output_html .cpf { color: #3D7B7B; font-style: italic } /* Comment.PreprocFile */\n",
-       ".output_html .c1 { color: #3D7B7B; font-style: italic } /* Comment.Single */\n",
-       ".output_html .cs { color: #3D7B7B; font-style: italic } /* Comment.Special */\n",
-       ".output_html .gd { color: #A00000 } /* Generic.Deleted */\n",
-       ".output_html .ge { font-style: italic } /* Generic.Emph */\n",
-       ".output_html .gr { color: #E40000 } /* Generic.Error */\n",
-       ".output_html .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
-       ".output_html .gi { color: #008400 } /* Generic.Inserted */\n",
-       ".output_html .go { color: #717171 } /* Generic.Output */\n",
-       ".output_html .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
-       ".output_html .gs { font-weight: bold } /* Generic.Strong */\n",
-       ".output_html .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       ".output_html .gt { color: #0044DD } /* Generic.Traceback */\n",
-       ".output_html .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
-       ".output_html .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
-       ".output_html .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
-       ".output_html .kp { color: #008000 } /* Keyword.Pseudo */\n",
-       ".output_html .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
-       ".output_html .kt { color: #B00040 } /* Keyword.Type */\n",
-       ".output_html .m { color: #666666 } /* Literal.Number */\n",
-       ".output_html .s { color: #BA2121 } /* Literal.String */\n",
-       ".output_html .na { color: #687822 } /* Name.Attribute */\n",
-       ".output_html .nb { color: #008000 } /* Name.Builtin */\n",
-       ".output_html .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       ".output_html .no { color: #880000 } /* Name.Constant */\n",
-       ".output_html .nd { color: #AA22FF } /* Name.Decorator */\n",
-       ".output_html .ni { color: #717171; font-weight: bold } /* Name.Entity */\n",
-       ".output_html .ne { color: #CB3F38; font-weight: bold } /* Name.Exception */\n",
-       ".output_html .nf { color: #0000FF } /* Name.Function */\n",
-       ".output_html .nl { color: #767600 } /* Name.Label */\n",
-       ".output_html .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
-       ".output_html .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
-       ".output_html .nv { color: #19177C } /* Name.Variable */\n",
-       ".output_html .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       ".output_html .w { color: #bbbbbb } /* Text.Whitespace */\n",
-       ".output_html .mb { color: #666666 } /* Literal.Number.Bin */\n",
-       ".output_html .mf { color: #666666 } /* Literal.Number.Float */\n",
-       ".output_html .mh { color: #666666 } /* Literal.Number.Hex */\n",
-       ".output_html .mi { color: #666666 } /* Literal.Number.Integer */\n",
-       ".output_html .mo { color: #666666 } /* Literal.Number.Oct */\n",
-       ".output_html .sa { color: #BA2121 } /* Literal.String.Affix */\n",
-       ".output_html .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
-       ".output_html .sc { color: #BA2121 } /* Literal.String.Char */\n",
-       ".output_html .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
-       ".output_html .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
-       ".output_html .s2 { color: #BA2121 } /* Literal.String.Double */\n",
-       ".output_html .se { color: #AA5D1F; font-weight: bold } /* Literal.String.Escape */\n",
-       ".output_html .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
-       ".output_html .si { color: #A45A77; font-weight: bold } /* Literal.String.Interpol */\n",
-       ".output_html .sx { color: #008000 } /* Literal.String.Other */\n",
-       ".output_html .sr { color: #A45A77 } /* Literal.String.Regex */\n",
-       ".output_html .s1 { color: #BA2121 } /* Literal.String.Single */\n",
-       ".output_html .ss { color: #19177C } /* Literal.String.Symbol */\n",
-       ".output_html .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       ".output_html .fm { color: #0000FF } /* Name.Function.Magic */\n",
-       ".output_html .vc { color: #19177C } /* Name.Variable.Class */\n",
-       ".output_html .vg { color: #19177C } /* Name.Variable.Global */\n",
-       ".output_html .vi { color: #19177C } /* Name.Variable.Instance */\n",
-       ".output_html .vm { color: #19177C } /* Name.Variable.Magic */\n",
-       ".output_html .il { color: #666666 } /* Literal.Number.Integer.Long */</style><div class=\"highlight\"><pre><span></span><span class=\"c1\">### BEGIN</span>\n",
-       "<span class=\"k\">def</span> <span class=\"nf\">_test_cell_</span><span class=\"p\">():</span>\n",
-       "\t<span class=\"c1\">#| echo: false</span>\n",
-       "\t<span class=\"n\">a</span> <span class=\"o\">=</span> <span class=\"s2\">&quot;&#39;a&#39; is not polluting global scope&quot;</span>\n",
-       "\t<span class=\"n\">a</span><span class=\"p\">;</span>\n",
-       "<span class=\"k\">try</span><span class=\"p\">:</span>\n",
-       "\t<span class=\"n\">_</span> <span class=\"o\">=</span> <span class=\"n\">_test_cell_</span><span class=\"p\">()</span>\n",
-       "<span class=\"k\">finally</span><span class=\"p\">:</span>\n",
-       "\t<span class=\"k\">del</span> <span class=\"n\">_test_cell_</span>\n",
-       "<span class=\"n\">_</span> <span class=\"c1\"># This will be added to global scope</span>\n",
-       "<span class=\"c1\">### END</span>\n",
-       "</pre></div>\n"
-      ],
-      "text/latex": [
-       "\\begin{Verbatim}[commandchars=\\\\\\{\\}]\n",
-       "\\PY{c+c1}{\\PYZsh{}\\PYZsh{}\\PYZsh{} BEGIN}\n",
-       "\\PY{k}{def} \\PY{n+nf}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\\PY{p}{(}\\PY{p}{)}\\PY{p}{:}\n",
-       "\t\\PY{c+c1}{\\PYZsh{}| echo: false}\n",
-       "\t\\PY{n}{a} \\PY{o}{=} \\PY{l+s+s2}{\\PYZdq{}}\\PY{l+s+s2}{\\PYZsq{}}\\PY{l+s+s2}{a}\\PY{l+s+s2}{\\PYZsq{}}\\PY{l+s+s2}{ is not polluting global scope}\\PY{l+s+s2}{\\PYZdq{}}\n",
-       "\t\\PY{n}{a}\\PY{p}{;}\n",
-       "\\PY{k}{try}\\PY{p}{:}\n",
-       "\t\\PY{n}{\\PYZus{}} \\PY{o}{=} \\PY{n}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\\PY{p}{(}\\PY{p}{)}\n",
-       "\\PY{k}{finally}\\PY{p}{:}\n",
-       "\t\\PY{k}{del} \\PY{n}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\n",
-       "\\PY{n}{\\PYZus{}} \\PY{c+c1}{\\PYZsh{} This will be added to global scope}\n",
-       "\\PY{c+c1}{\\PYZsh{}\\PYZsh{}\\PYZsh{} END}\n",
-       "\\end{Verbatim}\n"
+       "\n",
+       "      <div style=\"background-color: #808080; padding: 3px; text-align: center; font-size: 12px; color: white;\">\n",
+       "          This cell has been skipped\n",
+       "      </div>\n",
+       "      "
       ],
       "text/plain": [
-       "\n",
-       "### BEGIN\n",
-       "def _test_cell_():\n",
-       "\t#| echo: false\n",
-       "\ta = \"'a' is not polluting global scope\"\n",
-       "\ta;\n",
-       "try:\n",
-       "\t_ = _test_cell_()\n",
-       "finally:\n",
-       "\tdel _test_cell_\n",
-       "_ # This will be added to global scope\n",
-       "### END"
+       "<testcell.MessageBox>"
       ]
      },
      "metadata": {},
@@ -572,28 +241,11 @@
     }
    ],
    "source": [
-    "%%testcell verbose\n",
+    "%%testcell skip\n",
     "#| echo: false\n",
-    "a = \"'a' is not polluting global scope\"\n",
-    "a;"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "`testcell` works seamlessly with existing `print` or `display`statements on last line:"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "```python\n",
-    "%%testcell verbose\n",
-    "a = \"'a' is not polluting global scope\"\n",
-    "print(a)\n",
-    "```"
+    "#| output: false\n",
+    "# This is here for testing purpose\n",
+    "raise ValueError('This should not be executed')"
    ]
   },
   {
@@ -601,160 +253,37 @@
    "execution_count": null,
    "metadata": {},
    "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<style>pre { line-height: 125%; }\n",
-       "td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
-       "span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
-       "td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
-       "span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
-       ".output_html .hll { background-color: #ffffcc }\n",
-       ".output_html { background: #f8f8f8; }\n",
-       ".output_html .c { color: #3D7B7B; font-style: italic } /* Comment */\n",
-       ".output_html .err { border: 1px solid #FF0000 } /* Error */\n",
-       ".output_html .k { color: #008000; font-weight: bold } /* Keyword */\n",
-       ".output_html .o { color: #666666 } /* Operator */\n",
-       ".output_html .ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */\n",
-       ".output_html .cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */\n",
-       ".output_html .cp { color: #9C6500 } /* Comment.Preproc */\n",
-       ".output_html .cpf { color: #3D7B7B; font-style: italic } /* Comment.PreprocFile */\n",
-       ".output_html .c1 { color: #3D7B7B; font-style: italic } /* Comment.Single */\n",
-       ".output_html .cs { color: #3D7B7B; font-style: italic } /* Comment.Special */\n",
-       ".output_html .gd { color: #A00000 } /* Generic.Deleted */\n",
-       ".output_html .ge { font-style: italic } /* Generic.Emph */\n",
-       ".output_html .gr { color: #E40000 } /* Generic.Error */\n",
-       ".output_html .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
-       ".output_html .gi { color: #008400 } /* Generic.Inserted */\n",
-       ".output_html .go { color: #717171 } /* Generic.Output */\n",
-       ".output_html .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
-       ".output_html .gs { font-weight: bold } /* Generic.Strong */\n",
-       ".output_html .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       ".output_html .gt { color: #0044DD } /* Generic.Traceback */\n",
-       ".output_html .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
-       ".output_html .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
-       ".output_html .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
-       ".output_html .kp { color: #008000 } /* Keyword.Pseudo */\n",
-       ".output_html .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
-       ".output_html .kt { color: #B00040 } /* Keyword.Type */\n",
-       ".output_html .m { color: #666666 } /* Literal.Number */\n",
-       ".output_html .s { color: #BA2121 } /* Literal.String */\n",
-       ".output_html .na { color: #687822 } /* Name.Attribute */\n",
-       ".output_html .nb { color: #008000 } /* Name.Builtin */\n",
-       ".output_html .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       ".output_html .no { color: #880000 } /* Name.Constant */\n",
-       ".output_html .nd { color: #AA22FF } /* Name.Decorator */\n",
-       ".output_html .ni { color: #717171; font-weight: bold } /* Name.Entity */\n",
-       ".output_html .ne { color: #CB3F38; font-weight: bold } /* Name.Exception */\n",
-       ".output_html .nf { color: #0000FF } /* Name.Function */\n",
-       ".output_html .nl { color: #767600 } /* Name.Label */\n",
-       ".output_html .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
-       ".output_html .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
-       ".output_html .nv { color: #19177C } /* Name.Variable */\n",
-       ".output_html .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       ".output_html .w { color: #bbbbbb } /* Text.Whitespace */\n",
-       ".output_html .mb { color: #666666 } /* Literal.Number.Bin */\n",
-       ".output_html .mf { color: #666666 } /* Literal.Number.Float */\n",
-       ".output_html .mh { color: #666666 } /* Literal.Number.Hex */\n",
-       ".output_html .mi { color: #666666 } /* Literal.Number.Integer */\n",
-       ".output_html .mo { color: #666666 } /* Literal.Number.Oct */\n",
-       ".output_html .sa { color: #BA2121 } /* Literal.String.Affix */\n",
-       ".output_html .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
-       ".output_html .sc { color: #BA2121 } /* Literal.String.Char */\n",
-       ".output_html .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
-       ".output_html .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
-       ".output_html .s2 { color: #BA2121 } /* Literal.String.Double */\n",
-       ".output_html .se { color: #AA5D1F; font-weight: bold } /* Literal.String.Escape */\n",
-       ".output_html .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
-       ".output_html .si { color: #A45A77; font-weight: bold } /* Literal.String.Interpol */\n",
-       ".output_html .sx { color: #008000 } /* Literal.String.Other */\n",
-       ".output_html .sr { color: #A45A77 } /* Literal.String.Regex */\n",
-       ".output_html .s1 { color: #BA2121 } /* Literal.String.Single */\n",
-       ".output_html .ss { color: #19177C } /* Literal.String.Symbol */\n",
-       ".output_html .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       ".output_html .fm { color: #0000FF } /* Name.Function.Magic */\n",
-       ".output_html .vc { color: #19177C } /* Name.Variable.Class */\n",
-       ".output_html .vg { color: #19177C } /* Name.Variable.Global */\n",
-       ".output_html .vi { color: #19177C } /* Name.Variable.Instance */\n",
-       ".output_html .vm { color: #19177C } /* Name.Variable.Magic */\n",
-       ".output_html .il { color: #666666 } /* Literal.Number.Integer.Long */</style><div class=\"highlight\"><pre><span></span><span class=\"c1\">### BEGIN</span>\n",
-       "<span class=\"k\">def</span> <span class=\"nf\">_test_cell_</span><span class=\"p\">():</span>\n",
-       "\t<span class=\"c1\">#| echo: false</span>\n",
-       "\t<span class=\"n\">a</span> <span class=\"o\">=</span> <span class=\"s2\">&quot;&#39;a&#39; is not polluting global scope&quot;</span>\n",
-       "\t<span class=\"k\">return</span> <span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">a</span><span class=\"p\">)</span> <span class=\"c1\"># %%testcell</span>\n",
-       "<span class=\"k\">try</span><span class=\"p\">:</span>\n",
-       "\t<span class=\"n\">_</span> <span class=\"o\">=</span> <span class=\"n\">_test_cell_</span><span class=\"p\">()</span>\n",
-       "<span class=\"k\">finally</span><span class=\"p\">:</span>\n",
-       "\t<span class=\"k\">del</span> <span class=\"n\">_test_cell_</span>\n",
-       "<span class=\"n\">_</span> <span class=\"c1\"># This will be added to global scope</span>\n",
-       "<span class=\"c1\">### END</span>\n",
-       "</pre></div>\n"
-      ],
-      "text/latex": [
-       "\\begin{Verbatim}[commandchars=\\\\\\{\\}]\n",
-       "\\PY{c+c1}{\\PYZsh{}\\PYZsh{}\\PYZsh{} BEGIN}\n",
-       "\\PY{k}{def} \\PY{n+nf}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\\PY{p}{(}\\PY{p}{)}\\PY{p}{:}\n",
-       "\t\\PY{c+c1}{\\PYZsh{}| echo: false}\n",
-       "\t\\PY{n}{a} \\PY{o}{=} \\PY{l+s+s2}{\\PYZdq{}}\\PY{l+s+s2}{\\PYZsq{}}\\PY{l+s+s2}{a}\\PY{l+s+s2}{\\PYZsq{}}\\PY{l+s+s2}{ is not polluting global scope}\\PY{l+s+s2}{\\PYZdq{}}\n",
-       "\t\\PY{k}{return} \\PY{n+nb}{print}\\PY{p}{(}\\PY{n}{a}\\PY{p}{)} \\PY{c+c1}{\\PYZsh{} \\PYZpc{}\\PYZpc{}testcell}\n",
-       "\\PY{k}{try}\\PY{p}{:}\n",
-       "\t\\PY{n}{\\PYZus{}} \\PY{o}{=} \\PY{n}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\\PY{p}{(}\\PY{p}{)}\n",
-       "\\PY{k}{finally}\\PY{p}{:}\n",
-       "\t\\PY{k}{del} \\PY{n}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\n",
-       "\\PY{n}{\\PYZus{}} \\PY{c+c1}{\\PYZsh{} This will be added to global scope}\n",
-       "\\PY{c+c1}{\\PYZsh{}\\PYZsh{}\\PYZsh{} END}\n",
-       "\\end{Verbatim}\n"
-      ],
-      "text/plain": [
-       "\n",
-       "### BEGIN\n",
-       "def _test_cell_():\n",
-       "\t#| echo: false\n",
-       "\ta = \"'a' is not polluting global scope\"\n",
-       "\treturn print(a) # %%testcell\n",
-       "try:\n",
-       "\t_ = _test_cell_()\n",
-       "finally:\n",
-       "\tdel _test_cell_\n",
-       "_ # This will be added to global scope\n",
-       "### END"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "'a' is not polluting global scope\n"
+      "<testcell.MessageBox object>\n"
      ]
     }
    ],
    "source": [
-    "%%testcell verbose\n",
     "#| echo: false\n",
-    "a = \"'a' is not polluting global scope\"\n",
-    "print(a)"
+    "print(testcell.skip_message_box.__repr__())"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Moreover, thanks to `ast`, it properly deals with complex situations like comments on the last line and multi lines statements"
+    "To skip all `%%testcell` cells at once (useful for production runs), use: `testcell.global_skip = True`"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
+    "## Visual marking\n",
+    "\n",
+    "Use `banner` to display a colored indicator at the top of cell output, making test cells instantly recognizable:\n",
+    "\n",
     "```python\n",
-    "%%testcell verbose\n",
-    "a = \"'a' is not polluting global scope\"\n",
-    "(a,\n",
-    " True)\n",
-    "# this is a comment on last line\n",
+    "%%testcell banner\n",
+    "\"clearly marked\"\n",
     "```"
    ]
   },
@@ -764,176 +293,16 @@
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/html": [
-       "<style>pre { line-height: 125%; }\n",
-       "td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
-       "span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
-       "td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
-       "span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
-       ".output_html .hll { background-color: #ffffcc }\n",
-       ".output_html { background: #f8f8f8; }\n",
-       ".output_html .c { color: #3D7B7B; font-style: italic } /* Comment */\n",
-       ".output_html .err { border: 1px solid #FF0000 } /* Error */\n",
-       ".output_html .k { color: #008000; font-weight: bold } /* Keyword */\n",
-       ".output_html .o { color: #666666 } /* Operator */\n",
-       ".output_html .ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */\n",
-       ".output_html .cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */\n",
-       ".output_html .cp { color: #9C6500 } /* Comment.Preproc */\n",
-       ".output_html .cpf { color: #3D7B7B; font-style: italic } /* Comment.PreprocFile */\n",
-       ".output_html .c1 { color: #3D7B7B; font-style: italic } /* Comment.Single */\n",
-       ".output_html .cs { color: #3D7B7B; font-style: italic } /* Comment.Special */\n",
-       ".output_html .gd { color: #A00000 } /* Generic.Deleted */\n",
-       ".output_html .ge { font-style: italic } /* Generic.Emph */\n",
-       ".output_html .gr { color: #E40000 } /* Generic.Error */\n",
-       ".output_html .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
-       ".output_html .gi { color: #008400 } /* Generic.Inserted */\n",
-       ".output_html .go { color: #717171 } /* Generic.Output */\n",
-       ".output_html .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
-       ".output_html .gs { font-weight: bold } /* Generic.Strong */\n",
-       ".output_html .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       ".output_html .gt { color: #0044DD } /* Generic.Traceback */\n",
-       ".output_html .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
-       ".output_html .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
-       ".output_html .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
-       ".output_html .kp { color: #008000 } /* Keyword.Pseudo */\n",
-       ".output_html .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
-       ".output_html .kt { color: #B00040 } /* Keyword.Type */\n",
-       ".output_html .m { color: #666666 } /* Literal.Number */\n",
-       ".output_html .s { color: #BA2121 } /* Literal.String */\n",
-       ".output_html .na { color: #687822 } /* Name.Attribute */\n",
-       ".output_html .nb { color: #008000 } /* Name.Builtin */\n",
-       ".output_html .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       ".output_html .no { color: #880000 } /* Name.Constant */\n",
-       ".output_html .nd { color: #AA22FF } /* Name.Decorator */\n",
-       ".output_html .ni { color: #717171; font-weight: bold } /* Name.Entity */\n",
-       ".output_html .ne { color: #CB3F38; font-weight: bold } /* Name.Exception */\n",
-       ".output_html .nf { color: #0000FF } /* Name.Function */\n",
-       ".output_html .nl { color: #767600 } /* Name.Label */\n",
-       ".output_html .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
-       ".output_html .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
-       ".output_html .nv { color: #19177C } /* Name.Variable */\n",
-       ".output_html .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       ".output_html .w { color: #bbbbbb } /* Text.Whitespace */\n",
-       ".output_html .mb { color: #666666 } /* Literal.Number.Bin */\n",
-       ".output_html .mf { color: #666666 } /* Literal.Number.Float */\n",
-       ".output_html .mh { color: #666666 } /* Literal.Number.Hex */\n",
-       ".output_html .mi { color: #666666 } /* Literal.Number.Integer */\n",
-       ".output_html .mo { color: #666666 } /* Literal.Number.Oct */\n",
-       ".output_html .sa { color: #BA2121 } /* Literal.String.Affix */\n",
-       ".output_html .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
-       ".output_html .sc { color: #BA2121 } /* Literal.String.Char */\n",
-       ".output_html .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
-       ".output_html .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
-       ".output_html .s2 { color: #BA2121 } /* Literal.String.Double */\n",
-       ".output_html .se { color: #AA5D1F; font-weight: bold } /* Literal.String.Escape */\n",
-       ".output_html .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
-       ".output_html .si { color: #A45A77; font-weight: bold } /* Literal.String.Interpol */\n",
-       ".output_html .sx { color: #008000 } /* Literal.String.Other */\n",
-       ".output_html .sr { color: #A45A77 } /* Literal.String.Regex */\n",
-       ".output_html .s1 { color: #BA2121 } /* Literal.String.Single */\n",
-       ".output_html .ss { color: #19177C } /* Literal.String.Symbol */\n",
-       ".output_html .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       ".output_html .fm { color: #0000FF } /* Name.Function.Magic */\n",
-       ".output_html .vc { color: #19177C } /* Name.Variable.Class */\n",
-       ".output_html .vg { color: #19177C } /* Name.Variable.Global */\n",
-       ".output_html .vi { color: #19177C } /* Name.Variable.Instance */\n",
-       ".output_html .vm { color: #19177C } /* Name.Variable.Magic */\n",
-       ".output_html .il { color: #666666 } /* Literal.Number.Integer.Long */</style><div class=\"highlight\"><pre><span></span><span class=\"c1\">### BEGIN</span>\n",
-       "<span class=\"k\">def</span> <span class=\"nf\">_test_cell_</span><span class=\"p\">():</span>\n",
-       "\t<span class=\"c1\">#| echo: false</span>\n",
-       "\t<span class=\"n\">a</span> <span class=\"o\">=</span> <span class=\"s2\">&quot;&#39;a&#39; is not polluting global scope&quot;</span>\n",
-       "\t<span class=\"k\">return</span> <span class=\"p\">(</span><span class=\"n\">a</span><span class=\"p\">,</span>\n",
-       "\t <span class=\"kc\">True</span><span class=\"p\">)</span> <span class=\"c1\"># %%testcell</span>\n",
-       "<span class=\"k\">try</span><span class=\"p\">:</span>\n",
-       "\t<span class=\"n\">_</span> <span class=\"o\">=</span> <span class=\"n\">_test_cell_</span><span class=\"p\">()</span>\n",
-       "<span class=\"k\">finally</span><span class=\"p\">:</span>\n",
-       "\t<span class=\"k\">del</span> <span class=\"n\">_test_cell_</span>\n",
-       "<span class=\"n\">_</span> <span class=\"c1\"># This will be added to global scope</span>\n",
-       "<span class=\"c1\">### END</span>\n",
-       "</pre></div>\n"
-      ],
-      "text/latex": [
-       "\\begin{Verbatim}[commandchars=\\\\\\{\\}]\n",
-       "\\PY{c+c1}{\\PYZsh{}\\PYZsh{}\\PYZsh{} BEGIN}\n",
-       "\\PY{k}{def} \\PY{n+nf}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\\PY{p}{(}\\PY{p}{)}\\PY{p}{:}\n",
-       "\t\\PY{c+c1}{\\PYZsh{}| echo: false}\n",
-       "\t\\PY{n}{a} \\PY{o}{=} \\PY{l+s+s2}{\\PYZdq{}}\\PY{l+s+s2}{\\PYZsq{}}\\PY{l+s+s2}{a}\\PY{l+s+s2}{\\PYZsq{}}\\PY{l+s+s2}{ is not polluting global scope}\\PY{l+s+s2}{\\PYZdq{}}\n",
-       "\t\\PY{k}{return} \\PY{p}{(}\\PY{n}{a}\\PY{p}{,}\n",
-       "\t \\PY{k+kc}{True}\\PY{p}{)} \\PY{c+c1}{\\PYZsh{} \\PYZpc{}\\PYZpc{}testcell}\n",
-       "\\PY{k}{try}\\PY{p}{:}\n",
-       "\t\\PY{n}{\\PYZus{}} \\PY{o}{=} \\PY{n}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\\PY{p}{(}\\PY{p}{)}\n",
-       "\\PY{k}{finally}\\PY{p}{:}\n",
-       "\t\\PY{k}{del} \\PY{n}{\\PYZus{}test\\PYZus{}cell\\PYZus{}}\n",
-       "\\PY{n}{\\PYZus{}} \\PY{c+c1}{\\PYZsh{} This will be added to global scope}\n",
-       "\\PY{c+c1}{\\PYZsh{}\\PYZsh{}\\PYZsh{} END}\n",
-       "\\end{Verbatim}\n"
-      ],
-      "text/plain": [
-       "\n",
-       "### BEGIN\n",
-       "def _test_cell_():\n",
-       "\t#| echo: false\n",
-       "\ta = \"'a' is not polluting global scope\"\n",
-       "\treturn (a,\n",
-       "\t True) # %%testcell\n",
-       "try:\n",
-       "\t_ = _test_cell_()\n",
-       "finally:\n",
-       "\tdel _test_cell_\n",
-       "_ # This will be added to global scope\n",
-       "### END"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<testcell.MessageBox object>\n"
+     ]
     },
     {
      "data": {
       "text/plain": [
-       "(\"'a' is not polluting global scope\", True)"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "%%testcell verbose\n",
-    "#| echo: false\n",
-    "a = \"'a' is not polluting global scope\"\n",
-    "(a,\n",
-    " True)\n",
-    "# this is a comment on last line"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Skip execution\n",
-    "It is possible to skip a cell execution using `skip` command. This is usueful when you want to keep around the code but don't actually run it.\n",
-    "It's also possible to skip **all cells markked with `%%testcell`** using the following syntax: \n",
-    "`testcell.global_skip=True`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "        <div style=\"background-color: #808080; padding: 3px; text-align: center; font-size: 12px; color: white;\">\n",
-       "            This cell has been skipped\n",
-       "        </div>\n",
-       "        "
-      ],
-      "text/plain": [
-       "ℹ️ This cell has been skipped"
+       "'clearly marked'"
       ]
      },
      "metadata": {},
@@ -941,260 +310,117 @@
     }
    ],
    "source": [
-    "%%testcell skip\n",
     "#| echo: false\n",
-    "raise ValueError('This should not be executed')"
+    "print(testcell.testcell_message_box.__repr__())\n",
+    "display('clearly marked')"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Run in isolation\n",
+    "**The banner adapts to your environment.** In HTML-based notebooks like Jupyter, it displays as a full-width colored box. In console environments like IPython, it appears as text with an emoji.\n",
     "\n",
-    "`%%testcelln` is a shortcut for `%%testcell noglobals` and executes the cell in complete isolation from the global scope. \n",
-    "This is very useful when you want to ensure that global variables or namespaces are not accessible within the cell."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "aaa = 'global variable'"
+    "Colors and emojis are fully customizable through `testcell.params`.\n",
+    "\n",
+    "**IMPORTANT**: To enable banners for all `%%testcell` cells, use: **`testcell.global_use_banner = True`**"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
+    "## Run in complete isolation\n",
+    "\n",
+    "`%%testcelln` is a shortcut for `%%testcell noglobals` and executes cells with **zero access** to your notebook's global scope. Only Python's `__builtins__` are available.\n",
+    "\n",
+    "This is powerful for:\n",
+    "- **Detecting hidden dependencies**: catch when your code accidentally relies on global variables\n",
+    "- **Testing portability**: verify functions work standalone\n",
+    "- **Clean slate execution**: run code exactly as it would in a fresh Python session\n",
+    "\n",
+    "```python\n",
+    "my_global = \"I'm in the global scope\"\n",
+    "```\n",
+    "\n",
     "```python\n",
     "%%testcell\n",
-    "'aaa' in globals()\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "%%testcell \n",
-    "#| echo: false\n",
-    "'aaa' in globals()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
+    "'my_global' in globals()\n",
+    "```\n",
     "```python\n",
-    "%%testcell noglobals\n",
-    "'aaa' in globals()\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%%testcell noglobals\n",
-    "#| echo: false\n",
-    "'aaa' in globals()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
+    "    True # my_global is available\n",
+    "```\n",
     "```python\n",
     "%%testcelln\n",
-    "'aaa' in globals()\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%%testcelln\n",
-    "#| echo: false\n",
-    "'aaa' in globals()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
+    "'my_global' in globals()\n",
+    "```\n",
+    "```python\n",
+    "    False # my_global is NOT available\n",
+    "```\n",
     "```python\n",
     "%%testcelln\n",
     "globals().keys()\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "dict_keys(['__builtins__'])"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%%testcelln\n",
-    "#| echo: false\n",
-    "globals().keys()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "With `%%testcelln` inside the cell, you'll be able to access only  to `__builtins__` (aka: standard python's functions). **It behaves like a notebook-in-notebook**."
+    "```\n",
+    "```python\n",
+    "    dict_keys(['__builtins__'])\n",
+    "````"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "```python\n",
-    "%%testcell\n",
-    "def my_function(x):\n",
-    "    print(aaa) # global variable\n",
-    "    return x\n",
+    "## Explicit dependencies\n",
     "\n",
-    "try:\n",
-    "    my_function(123)\n",
-    "except Exception as e:\n",
-    "    print(e)\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "global variable\n"
-     ]
-    }
-   ],
-   "source": [
-    "%%testcell\n",
-    "#| echo: false\n",
-    "def my_function(x):\n",
-    "    print(aaa) # global variable\n",
-    "    return x\n",
+    "The `(inputs)->(outputs)` syntax gives you precise control: you can pass any symbol (variables, functions, classes) into the isolated context and save only chosen ones back to globals.\n",
+    "\n",
+    "This **forces explicit dependency declaration**, giving you full control over what enters and exits the cell. It prevents accidental reliance on symbols from the main context that would hurt you when exporting the code.\n",
     "\n",
-    "try:\n",
-    "    my_function(123)\n",
-    "except Exception as e:\n",
-    "    print(e)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
     "```python\n",
-    "%%testcelln\n",
-    "def my_function(x):\n",
-    "    print(aaa) # global variable\n",
-    "    return x\n",
+    "data = [1, 2, 3, 4, 5]\n",
+    "```\n",
     "\n",
-    "try:\n",
-    "    my_function(123)\n",
-    "except Exception as e:\n",
-    "    print(e)\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "name 'aaa' is not defined\n"
-     ]
-    }
-   ],
-   "source": [
-    "%%testcelln\n",
-    "#| echo: false\n",
-    "def my_function(x):\n",
-    "    print(aaa) # global variable\n",
-    "    return x\n",
+    "```python\n",
+    "%%testcelln (data)->(calculate_stats)\n",
+    "# Only 'data' is available, only 'calculate_stats' is saved\n",
     "\n",
-    "try:\n",
-    "    my_function(123)\n",
-    "except Exception as e:\n",
-    "    print(e)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "As you can see from this last example, `%%testcelln` helps you to identify that `my_function` refers global variable `aaa`."
+    "def calculate_stats(values):\n",
+    "    return {\n",
+    "        'mean': sum(values) / len(values),\n",
+    "        'min': min(values),\n",
+    "        'max': max(values)\n",
+    "    }\n",
+    "\n",
+    "# Test it works\n",
+    "print(calculate_stats(data))\n",
+    "```\n",
+    "\n",
+    "    {'mean': 3.0, 'min': 1, 'max': 5}\n",
+    "\n",
+    "`calculate_stats` now **exists in globals**. No test code or intermediate variables leaked.\n",
+    "\n",
+    "```python\n",
+    "calculate_stats([10, 20, 30])\n",
+    "```\n",
+    "\n",
+    "    {'mean': 20.0, 'min': 10, 'max': 30}"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "**IMPORTANT**: this is *just wrapping your cell*  and so it's still running on your main kernel. If you modify variables that has been created outside of this cell (aka: if you have side effects) this will not protect you."
+    "## Advanced parsing\n",
+    "\n",
+    "Thanks to Python's `ast` module, `%%testcell` correctly handles complex code patterns including comments on the last line and multi-line statements:\n",
+    "\n",
+    "```python\n",
+    "%%testcell verbose\n",
+    "result = \"complex parsing\"\n",
+    "(result,\n",
+    " True)\n",
+    "# comment on last line\n",
+    "```"
    ]
   },
   {
@@ -1204,51 +430,44 @@
    "outputs": [
     {
      "data": {
+      "text/markdown": [
+       "```python\n",
+       "### BEGIN\n",
+       "def _test_cell_():\n",
+       "\t#| echo: false\n",
+       "\tresult = \"complex parsing\"\n",
+       "\treturn (result,\n",
+       "\t True) # %%testcell\n",
+       "try:\n",
+       "\t_ = _test_cell_()\n",
+       "finally:\n",
+       "\tdel _test_cell_\n",
+       "_ # This will be added to global scope\n",
+       "### END\n",
+       "```"
+      ],
       "text/plain": [
-       "'global variable'"
+       "### BEGIN\n",
+       "def _test_cell_():\n",
+       "\t#| echo: false\n",
+       "\tresult = \"complex parsing\"\n",
+       "\treturn (result,\n",
+       "\t True) # %%testcell\n",
+       "try:\n",
+       "\t_ = _test_cell_()\n",
+       "finally:\n",
+       "\tdel _test_cell_\n",
+       "_ # This will be added to global scope\n",
+       "### END"
       ]
      },
-     "execution_count": null,
      "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "aaa"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "```python\n",
-    "%%testcell \n",
-    "# WARNING: this will alter the state of global variable:\n",
-    "globals().update({'aaa' : 'modified global variable'});\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%%testcell \n",
-    "#| echo: false\n",
-    "# WARNING: this will alter the state of global variable:\n",
-    "globals().update({'aaa' : 'modified global variable'});"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
+     "output_type": "display_data"
+    },
     {
      "data": {
       "text/plain": [
-       "'modified global variable'"
+       "('complex parsing', True)"
       ]
      },
      "execution_count": null,
@@ -1257,16 +476,12 @@
     }
    ],
    "source": [
-    "aaa"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "del aaa"
+    "%%testcell verbose\n",
+    "#| echo: false\n",
+    "result = \"complex parsing\"\n",
+    "(result,\n",
+    " True)\n",
+    "# comment on last line"
    ]
   },
   {
@@ -1278,8 +493,11 @@
     "+ PROJECT PAGE: [https://github.com/artste/testcell](https://github.com/artste/testcell)\n",
     "+ DOCUMENTATION: [https://artste.github.io/testcell](https://artste.github.io/testcell)\n",
     "+ PYPI: [https://pypi.org/project/testcell](https://pypi.org/project/testcell)\n",
+    "+ DETAILED DEMO: <https://github.com/artste/testcell/blob/main/demo/testcell_demo.ipynb>\n",
+    "+ USE CASE ZOO: <https://github.com/artste/testcell/blob/main/demo/testcell_zoo.ipynb>\n",
+    "+ LAUNCHING BLOG: [Introducing `%%testcell`](https://artste.github.io/blog/posts/introducing-testcell)\n",
     "+ COLAB DEMO: [testcell_demo.ipynb](https://colab.research.google.com/github/artste/testcell/blob/main/demo/testcell_demo.ipynb)\n",
-    "+ KAGGLE SAMPLE NOTEBOOK: [https://www.kaggle.com/artste/introducing-testcell](https://www.kaggle.com/artste/introducing-testcell)"
+    "+ KAGGLE SAMPLE NOTEBOOK: <https://www.kaggle.com/artste/introducing-testcell>"
    ]
   },
   {
diff --git a/nbs/sidebar.yml b/nbs/sidebar.yml
index b3f3257..7b5ea2e 100644
--- a/nbs/sidebar.yml
+++ b/nbs/sidebar.yml
@@ -3,4 +3,5 @@ website:
     contents:
       - index.ipynb
       - 01_ast.ipynb
+      - 01a_arguments.ipynb
       - 02_testcell.ipynb
diff --git a/testcell/__init__.py b/testcell/__init__.py
index eb5b33d..6138474 100644
--- a/testcell/__init__.py
+++ b/testcell/__init__.py
@@ -3,18 +3,19 @@
 
 # %% auto 0
 __all__ = ['global_skip', 'global_use_banner', 'params', 'skip_message_box', 'testcell_message_box', 'noglobals_message_box',
-           'MessageBox', 'testcell', 'testcelln']
+           'testcell_valid_args', 'TestcellArgs', 'Inout', 'MessageBox', 'Code', 'parse_args', 'parse_testcell_args',
+           'testcell', 'testcelln']
 
 # %% ../nbs/02_testcell.ipynb 4
 import ast
 from IPython.core.magic import register_cell_magic, needs_local_scope
 from IPython import get_ipython # needed for quarto
-from IPython.display import Code
 
-# %% ../nbs/02_testcell.ipynb 5
+# %% ../nbs/02_testcell.ipynb 6
 from .core import auto_return
+from .inout import separate_args_and_inout, process_inout, split_and_strip, validate_and_update_inputs
 
-# %% ../nbs/02_testcell.ipynb 6
+# %% ../nbs/02_testcell.ipynb 7
 global_skip = False # If true all %%testcell cells will be skipped
 global_use_banner = False # if true it shows a banner on the cell's output
 
@@ -25,36 +26,75 @@
     'skip_background':'#808080', 'skip_text':'white', 'skip_emoji':'ℹ️',   
 }
 
-# %% ../nbs/02_testcell.ipynb 8
-# Temporary class to deal with different display options (jupyter or console)
+# %% ../nbs/02_testcell.ipynb 10
+import html
+
 class MessageBox:
     def __init__(self,data,*,background_color,text_color,emoji=None):
         self.data = data
         self.background_color = background_color
         self.text_color = text_color
         self.emoji = emoji
-
+        
     def _repr_html_(self):
+        # Escape all user-controllable values
+        safe_bg = html.escape(str(self.background_color), quote=True)
+        safe_text = html.escape(str(self.text_color), quote=True)
+        safe_data = html.escape(str(self.data))
+        
         return f"""
-        <div style="background-color: {self.background_color}; padding: 3px; text-align: center; font-size: 12px; color: {self.text_color};">
-            {self.data}
-        </div>
-        """
+            <div style="background-color: {safe_bg}; padding: 3px; text-align: center; font-size: 12px; color: {safe_text};">
+              {safe_data}
+            </div>
+            """
 
     def __repr__(self): 
         text = self.data
         if self.emoji is not None: text = self.emoji + " " + text
         return text
 
-# %% ../nbs/02_testcell.ipynb 9
+# %% ../nbs/02_testcell.ipynb 12
 skip_message_box= MessageBox('This cell has been skipped',background_color=params['skip_background'],text_color=params['skip_text'],emoji=params['skip_emoji'])
 testcell_message_box = MessageBox("testcell",background_color=params['testcell_background'],text_color=params['testcell_text'],emoji=params['testcell_emoji'])
 noglobals_message_box = MessageBox("testcell noglobals",background_color=params['noglobals_background'],text_color=params['noglobals_text'],emoji=params['noglobals_emoji'])
 
-# %% ../nbs/02_testcell.ipynb 13
+# %% ../nbs/02_testcell.ipynb 17
+from IPython.display import Markdown
+
+class Code:
+    def __init__(self, data=None, url=None, filename=None, language='python'):
+        self.data = data
+        self.language = language
+        # NOTE: skipping other arguments, we're keeling them only for backward compatibility
+    def _repr_markdown_(self): return Markdown(f"```{self.language}\n{self.data}\n```")._repr_markdown_()
+    def __repr__(self): return self.data
+
+# %% ../nbs/02_testcell.ipynb 21
+testcell_valid_args = {'verbose','dryrun','noglobals','noreturn','skip','banner','debug'} # full commands set
+
+# %% ../nbs/02_testcell.ipynb 22
+def parse_args(x):
+    t = set([c for c in split_and_strip(x,' ') if c != ''])
+    diff = t.difference(testcell_valid_args)
+    if len(diff)>0: raise ValueError(f'Invalid arguments passed: "{",".join(diff)}"')
+    return t
+
+# %% ../nbs/02_testcell.ipynb 25
+from collections import namedtuple
+TestcellArgs = namedtuple('TestcellArgs','args inout')
+Inout = namedtuple('Inout','input output')
+
+# %% ../nbs/02_testcell.ipynb 26
+def parse_testcell_args(x:str)->TestcellArgs:
+    raw_args,raw_inout = separate_args_and_inout(x)
+    return TestcellArgs(parse_args(raw_args),None if raw_inout is None else Inout(*process_inout(raw_inout)))
+
+# %% ../nbs/02_testcell.ipynb 29
 @register_cell_magic
 @needs_local_scope
 def testcell(line, cell, local_ns):
+    args,inout = parse_testcell_args(line)
+    
     # Parse arguments
     verbose = 'verbose' in line # enable verbose 
     dryrun = 'dryrun' in line # this will avoid running the code and just print out the code like verbose
@@ -62,23 +102,37 @@ def testcell(line, cell, local_ns):
     noreturn = 'noreturn' in line # display but does not return anything, so no memory "footprint" after execution
     skip = ('skip' in line) or global_skip # skip cell execution
     use_banner = ('banner' in line) or global_use_banner # shows a contextual banner at top of the cell
+    debug = 'debug' in args # debug mode shows both code and all the update to the globals 
     
     # arguments rules
     if noglobals or dryrun: noreturn=True
     if dryrun: verbose=True
+    if debug: verbose=True
 
     # skip
     if skip: 
         display(skip_message_box)
         return None # exits
-
     
     # Do the job
     cell = auto_return(cell)
     lines = cell.splitlines()
+    
+    # Globals management
+    _globals = {} if noglobals else local_ns
+    _locals = {'_':None} if noreturn else None # we mask '_' with a local variable to prevent it affecting global scope
 
+    # Deal with inout
+    outputs = None
+    globals_definitions = []
+    if inout is not None:
+        inputs,outputs = inout.input,inout.output
+        _globals.update(validate_and_update_inputs(inputs,local_ns)) # inputs
+        for o in outputs: globals_definitions += ['\t'+f'global {o}'] # outputs
+    
     # Wrap inside a function and execute it
     arr = ['def _test_cell_():']
+    arr += globals_definitions
     arr += ['\t'+x for x in lines]
     arr += ['try:\n\t_ = _test_cell_()'] # execute it and assign result to '_'
     arr += ['finally:\n\tdel _test_cell_'] # delete it
@@ -88,17 +142,21 @@ def testcell(line, cell, local_ns):
         arr += ['_ # This will be added to global scope'] # having this as last line makes the same behavior as normal cell
     wrapped_cell = '\n'.join(arr)
 
-    if verbose: display(Code('\n### BEGIN\n'+wrapped_cell+'\n### END',language='python'))
-
-    _globals = {} if noglobals else local_ns
-    _locals = {'_':None} if noreturn else None # we mask '_' with a local variable to prevent it affecting global scope
-    if not 'dryrun' in line: 
-        if use_banner: display(noglobals_message_box if noglobals else testcell_message_box)
-        exec(wrapped_cell,_globals,_locals)
-    
+    if use_banner: display(noglobals_message_box if noglobals else testcell_message_box)
+    if verbose: display(Code('### BEGIN\n'+wrapped_cell+'\n### END',language='python'))
+
+    if not dryrun: exec(wrapped_cell,_globals,_locals)
+        
+    if (outputs is not None) and (len(outputs)>0) and (not dryrun):
+        arr2 = []
+        for o in outputs: arr2 += [f'global {o}; {o}=locals()["{o}"]'] # this forwards objects to global scope
+        globals_update_code = '\n'.join(arr2)
+        if debug: display(Code('### GLOBALS UPDATE CODE:\n'+globals_update_code+'\n###',language='python'))
+        exec(globals_update_code,local_ns,_globals)
+        
     return None if noreturn else _globals.get('_',None) # this closes the loop of integration
 
-# %% ../nbs/02_testcell.ipynb 17
+# %% ../nbs/02_testcell.ipynb 33
 @register_cell_magic
 @needs_local_scope
 def testcelln(line, cell, local_ns):
diff --git a/testcell/_modidx.py b/testcell/_modidx.py
index c54a55d..8c5445c 100644
--- a/testcell/_modidx.py
+++ b/testcell/_modidx.py
@@ -15,4 +15,12 @@
                                'testcell.core.last_node': ('ast.html#last_node', 'testcell/core.py'),
                                'testcell.core.last_statement_has_semicolon': ('ast.html#last_statement_has_semicolon', 'testcell/core.py'),
                                'testcell.core.need_return': ('ast.html#need_return', 'testcell/core.py'),
-                               'testcell.core.node_source': ('ast.html#node_source', 'testcell/core.py')}}}
+                               'testcell.core.node_source': ('ast.html#node_source', 'testcell/core.py')},
+            'testcell.inout': { 'testcell.inout.count_char': ('arguments.html#count_char', 'testcell/inout.py'),
+                                'testcell.inout.count_delta': ('arguments.html#count_delta', 'testcell/inout.py'),
+                                'testcell.inout.optional_find': ('arguments.html#optional_find', 'testcell/inout.py'),
+                                'testcell.inout.process_inout': ('arguments.html#process_inout', 'testcell/inout.py'),
+                                'testcell.inout.separate_args_and_inout': ('arguments.html#separate_args_and_inout', 'testcell/inout.py'),
+                                'testcell.inout.split_and_strip': ('arguments.html#split_and_strip', 'testcell/inout.py'),
+                                'testcell.inout.validate_and_update_inputs': ( 'arguments.html#validate_and_update_inputs',
+                                                                               'testcell/inout.py')}}}
diff --git a/testcell/inout.py b/testcell/inout.py
new file mode 100644
index 0000000..a21519d
--- /dev/null
+++ b/testcell/inout.py
@@ -0,0 +1,69 @@
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/01a_arguments.ipynb.
+
+# %% auto 0
+__all__ = ['optional_find', 'count_char', 'count_delta', 'split_and_strip', 'process_inout', 'separate_args_and_inout',
+           'validate_and_update_inputs']
+
+# %% ../nbs/01a_arguments.ipynb 6
+def optional_find(x,cc,reverse=False):
+    if isinstance(cc,str): cc = [cc] # listify
+    t = [(x.rfind(c) if reverse else x.find(c),c) for c in cc]
+    t = [(f,c) for f,c in t if f != -1]
+    if len(t)==0: return None
+    return max(t) if reverse else min(t)
+
+# %% ../nbs/01a_arguments.ipynb 9
+def count_char(x,c):
+    # Count how many times c appears in x
+    return sum(map(lambda y: y==c,x))
+
+# %% ../nbs/01a_arguments.ipynb 11
+def count_delta(x,a='(',b=')'):
+    # Return the difference between the count of "a" and "b".
+    return count_char(x,a) - count_char(x,b)
+
+# %% ../nbs/01a_arguments.ipynb 14
+def split_and_strip(x,splitter):
+    t = [t.strip() for t in x.split(splitter)]
+    if t==['']: return []
+    return t
+
+# %% ../nbs/01a_arguments.ipynb 17
+def process_inout(x,splitter='->'):
+    if x is None: return None
+    t = split_and_strip(x,splitter)
+    for v,c,n in zip(t,map(count_delta,t),map(lambda s: count_char(s,'('),t)): 
+        if n>1: raise ValueError(f'Too much parenthesis on "{v}"')
+        if c>0: raise ValueError(f'Missing closing parenthesis on "{v}"')
+    t = [x[1:-1] for x in t]
+    if len(t)==0: raise ValueError('No groups available')
+    if len(t)>2: raise ValueError(f'You should have only one "{splitter}" symbol')
+    if len(t)==1: return split_and_strip(t[0],','),[]
+    if len(t)==2: return split_and_strip(t[0],','),split_and_strip(t[1],',')
+
+# %% ../nbs/01a_arguments.ipynb 19
+def separate_args_and_inout(x):
+    if x is None: return None
+    if (start_t := optional_find(x,['(','->'],reverse=False)) and (end_t := optional_find(x,[')','->'],reverse=True)):
+        start,_ = start_t
+        end, c = end_t
+        length = len(c)
+        return x[:start]+x[end+length:],x[start:end+length]
+    return x,None
+
+# %% ../nbs/01a_arguments.ipynb 22
+def validate_and_update_inputs(inputs:list,state:dict,)->dict:
+  s = set(inputs)
+  ret = {}
+  missing = []
+  for k in inputs:
+      if k not in state:
+          missing.append(k)
+      else:
+          ret[k] = state[k]
+
+  if missing:
+      # Generic error that doesn't reveal what DOES exist
+      raise ValueError(f'Required input variable(s) not found: {", ".join(missing)}')
+
+  return ret