diff --git a/docs/source/_exts/autogen_api_docs.py b/docs/source/_exts/autogen_api_docs.py
index 2522ad388..cdd1f184e 100644
--- a/docs/source/_exts/autogen_api_docs.py
+++ b/docs/source/_exts/autogen_api_docs.py
@@ -43,7 +43,7 @@ def generate_api_docs():
         if file.name == "__init__.py":
             if file.parent != PYTHON_PACKAGE:
                 content.append(make_package_section(file))
-        else:
+        elif not file.name.startswith("_"):
             content.append(make_module_section(file))
 
     API_FILE.write_text("\n".join(content))
diff --git a/docs/source/about/changelog.rst b/docs/source/about/changelog.rst
index ccbd3d728..e7a0b6ccf 100644
--- a/docs/source/about/changelog.rst
+++ b/docs/source/about/changelog.rst
@@ -19,6 +19,14 @@ Unreleased
 
 - :pull:`1251` - Substitute client-side usage of ``react`` with ``preact``.
 - :pull:`1239` - Script elements no longer support behaving like effects. They now strictly behave like plain HTML script elements.
+- :pull:`1255` - The ``reactpy.html`` module has been modified to allow for auto-creation of any HTML nodes. For example, you can create a ``<data-table>`` element by calling ``html.data_table()``.
+
+**Removed**
+
+- :pull:`1255` - Removed the ability to import ``reactpy.html.*`` elements directly. You must now call ``html.*`` to access the elements.
+- :pull:`1255` - Removed ``reactpy.sample`` module.
+- :pull:`1255` - Removed ``reactpy.svg`` module. Contents previously within ``reactpy.svg.*`` can now be accessed via ``html.svg.*``.
+- :pull:`1255` - Removed ``reactpy.html._`` function. Use ``html.fragment`` instead.
 
 **Fixed**
 
diff --git a/docs/source/guides/getting-started/_examples/run_starlette.py b/docs/source/guides/getting-started/_examples/run_starlette.py
index 966b9ef77..47a08fb47 100644
--- a/docs/source/guides/getting-started/_examples/run_starlette.py
+++ b/docs/source/guides/getting-started/_examples/run_starlette.py
@@ -1,4 +1,4 @@
-# :lines: 11-
+# :lines: 10-
 
 from reactpy import run
 from reactpy.backend import starlette as starlette_server
diff --git a/src/reactpy/__init__.py b/src/reactpy/__init__.py
index d54e82174..f22aa5832 100644
--- a/src/reactpy/__init__.py
+++ b/src/reactpy/__init__.py
@@ -1,4 +1,5 @@
-from reactpy import backend, config, html, logging, sample, svg, types, web, widgets
+from reactpy import backend, config, logging, types, web, widgets
+from reactpy._html import html
 from reactpy.backend.utils import run
 from reactpy.core import hooks
 from reactpy.core.component import component
@@ -37,8 +38,6 @@
     "html_to_vdom",
     "logging",
     "run",
-    "sample",
-    "svg",
     "types",
     "use_callback",
     "use_connection",
diff --git a/src/reactpy/_html.py b/src/reactpy/_html.py
new file mode 100644
index 000000000..e2d4f096a
--- /dev/null
+++ b/src/reactpy/_html.py
@@ -0,0 +1,416 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, ClassVar
+
+from reactpy.core.vdom import custom_vdom_constructor, make_vdom_constructor
+
+if TYPE_CHECKING:
+    from reactpy.core.types import (
+        EventHandlerDict,
+        Key,
+        VdomAttributes,
+        VdomChild,
+        VdomChildren,
+        VdomDict,
+        VdomDictConstructor,
+    )
+
+__all__ = ["html"]
+
+NO_CHILDREN_ALLOWED_HTML_BODY = {
+    "area",
+    "base",
+    "br",
+    "col",
+    "command",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "iframe",
+    "keygen",
+    "link",
+    "meta",
+    "param",
+    "portal",
+    "source",
+    "track",
+    "wbr",
+}
+
+NO_CHILDREN_ALLOWED_SVG = {
+    "animate",
+    "animateMotion",
+    "animateTransform",
+    "circle",
+    "desc",
+    "discard",
+    "ellipse",
+    "feBlend",
+    "feColorMatrix",
+    "feComponentTransfer",
+    "feComposite",
+    "feConvolveMatrix",
+    "feDiffuseLighting",
+    "feDisplacementMap",
+    "feDistantLight",
+    "feDropShadow",
+    "feFlood",
+    "feFuncA",
+    "feFuncB",
+    "feFuncG",
+    "feFuncR",
+    "feGaussianBlur",
+    "feImage",
+    "feMerge",
+    "feMergeNode",
+    "feMorphology",
+    "feOffset",
+    "fePointLight",
+    "feSpecularLighting",
+    "feSpotLight",
+    "feTile",
+    "feTurbulence",
+    "filter",
+    "foreignObject",
+    "hatch",
+    "hatchpath",
+    "image",
+    "line",
+    "linearGradient",
+    "metadata",
+    "mpath",
+    "path",
+    "polygon",
+    "polyline",
+    "radialGradient",
+    "rect",
+    "script",
+    "set",
+    "stop",
+    "style",
+    "text",
+    "textPath",
+    "title",
+    "tspan",
+    "use",
+    "view",
+}
+
+
+def _fragment(
+    attributes: VdomAttributes,
+    children: Sequence[VdomChild],
+    key: Key | None,
+    event_handlers: EventHandlerDict,
+) -> VdomDict:
+    """An HTML fragment - this element will not appear in the DOM"""
+    if attributes or event_handlers:
+        msg = "Fragments cannot have attributes besides 'key'"
+        raise TypeError(msg)
+    model: VdomDict = {"tagName": ""}
+
+    if children:
+        model["children"] = children
+
+    if key is not None:
+        model["key"] = key
+
+    return model
+
+
+def _script(
+    attributes: VdomAttributes,
+    children: Sequence[VdomChild],
+    key: Key | None,
+    event_handlers: EventHandlerDict,
+) -> VdomDict:
+    """Create a new `<script> <https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script>`__ element.
+
+    .. warning::
+
+        Be careful to sanitize data from untrusted sources before using it in a script.
+        See the "Notes" for more details
+
+    This behaves slightly differently than a normal script element in that it may be run
+    multiple times if its key changes (depending on specific browser behaviors). If no
+    key is given, the key is inferred to be the content of the script or, lastly its
+    'src' attribute if that is given.
+
+    Notes:
+        Do not use unsanitized data from untrusted sources anywhere in your script.
+        Doing so may allow for malicious code injection
+        (`XSS <https://en.wikipedia.org/wiki/Cross-site_scripting>`__`).
+    """
+    model: VdomDict = {"tagName": "script"}
+
+    if event_handlers:
+        msg = "'script' elements do not support event handlers"
+        raise ValueError(msg)
+
+    if children:
+        if len(children) > 1:
+            msg = "'script' nodes may have, at most, one child."
+            raise ValueError(msg)
+        if not isinstance(children[0], str):
+            msg = "The child of a 'script' must be a string."
+            raise ValueError(msg)
+        model["children"] = children
+        if key is None:
+            key = children[0]
+
+    if attributes:
+        model["attributes"] = attributes
+        if key is None and not children and "src" in attributes:
+            key = attributes["src"]
+
+    if key is not None:
+        model["key"] = key
+
+    return model
+
+
+class SvgConstructor:
+    """Constructor specifically for SVG children."""
+
+    __cache__: ClassVar[dict[str, VdomDictConstructor]] = {}
+
+    def __call__(
+        self, *attributes_and_children: VdomAttributes | VdomChildren
+    ) -> VdomDict:
+        return self.svg(*attributes_and_children)
+
+    def __getattr__(self, value: str) -> VdomDictConstructor:
+        value = value.rstrip("_").replace("_", "-")
+
+        if value in self.__cache__:
+            return self.__cache__[value]
+
+        self.__cache__[value] = make_vdom_constructor(
+            value, allow_children=value not in NO_CHILDREN_ALLOWED_SVG
+        )
+
+        return self.__cache__[value]
+
+    # SVG child elements, written out here for auto-complete purposes
+    # The actual elements are created dynamically in the __getattr__ method.
+    # Elements other than these can still be created.
+    a: VdomDictConstructor
+    animate: VdomDictConstructor
+    animateMotion: VdomDictConstructor
+    animateTransform: VdomDictConstructor
+    circle: VdomDictConstructor
+    clipPath: VdomDictConstructor
+    defs: VdomDictConstructor
+    desc: VdomDictConstructor
+    discard: VdomDictConstructor
+    ellipse: VdomDictConstructor
+    feBlend: VdomDictConstructor
+    feColorMatrix: VdomDictConstructor
+    feComponentTransfer: VdomDictConstructor
+    feComposite: VdomDictConstructor
+    feConvolveMatrix: VdomDictConstructor
+    feDiffuseLighting: VdomDictConstructor
+    feDisplacementMap: VdomDictConstructor
+    feDistantLight: VdomDictConstructor
+    feDropShadow: VdomDictConstructor
+    feFlood: VdomDictConstructor
+    feFuncA: VdomDictConstructor
+    feFuncB: VdomDictConstructor
+    feFuncG: VdomDictConstructor
+    feFuncR: VdomDictConstructor
+    feGaussianBlur: VdomDictConstructor
+    feImage: VdomDictConstructor
+    feMerge: VdomDictConstructor
+    feMergeNode: VdomDictConstructor
+    feMorphology: VdomDictConstructor
+    feOffset: VdomDictConstructor
+    fePointLight: VdomDictConstructor
+    feSpecularLighting: VdomDictConstructor
+    feSpotLight: VdomDictConstructor
+    feTile: VdomDictConstructor
+    feTurbulence: VdomDictConstructor
+    filter: VdomDictConstructor
+    foreignObject: VdomDictConstructor
+    g: VdomDictConstructor
+    hatch: VdomDictConstructor
+    hatchpath: VdomDictConstructor
+    image: VdomDictConstructor
+    line: VdomDictConstructor
+    linearGradient: VdomDictConstructor
+    marker: VdomDictConstructor
+    mask: VdomDictConstructor
+    metadata: VdomDictConstructor
+    mpath: VdomDictConstructor
+    path: VdomDictConstructor
+    pattern: VdomDictConstructor
+    polygon: VdomDictConstructor
+    polyline: VdomDictConstructor
+    radialGradient: VdomDictConstructor
+    rect: VdomDictConstructor
+    script: VdomDictConstructor
+    set: VdomDictConstructor
+    stop: VdomDictConstructor
+    style: VdomDictConstructor
+    switch: VdomDictConstructor
+    symbol: VdomDictConstructor
+    text: VdomDictConstructor
+    textPath: VdomDictConstructor
+    title: VdomDictConstructor
+    tspan: VdomDictConstructor
+    use: VdomDictConstructor
+    view: VdomDictConstructor
+
+
+class HtmlConstructor:
+    """Create a new HTML element. Commonly used elements are provided via auto-complete.
+    However, any HTML element can be created by calling the element name as an attribute.
+
+    If trying to create an element that is illegal syntax in Python, you can postfix an
+    underscore character (eg. `html.del_` for `<del>`).
+
+    If trying to create an element with dashes in the name, you can replace the dashes
+    with underscores (eg. `html.data_table` for `<data-table>`)."""
+
+    # ruff: noqa: N815
+    __cache__: ClassVar[dict[str, VdomDictConstructor]] = {
+        "script": custom_vdom_constructor(_script),
+        "fragment": custom_vdom_constructor(_fragment),
+    }
+
+    def __getattr__(self, value: str) -> VdomDictConstructor:
+        value = value.rstrip("_").replace("_", "-")
+
+        if value in self.__cache__:
+            return self.__cache__[value]
+
+        self.__cache__[value] = make_vdom_constructor(
+            value, allow_children=value not in NO_CHILDREN_ALLOWED_HTML_BODY
+        )
+
+        return self.__cache__[value]
+
+    # HTML elements, written out here for auto-complete purposes
+    # The actual elements are created dynamically in the __getattr__ method.
+    # Elements other than these can still be created.
+    a: VdomDictConstructor
+    abbr: VdomDictConstructor
+    address: VdomDictConstructor
+    area: VdomDictConstructor
+    article: VdomDictConstructor
+    aside: VdomDictConstructor
+    audio: VdomDictConstructor
+    b: VdomDictConstructor
+    body: VdomDictConstructor
+    base: VdomDictConstructor
+    bdi: VdomDictConstructor
+    bdo: VdomDictConstructor
+    blockquote: VdomDictConstructor
+    br: VdomDictConstructor
+    button: VdomDictConstructor
+    canvas: VdomDictConstructor
+    caption: VdomDictConstructor
+    cite: VdomDictConstructor
+    code: VdomDictConstructor
+    col: VdomDictConstructor
+    colgroup: VdomDictConstructor
+    data: VdomDictConstructor
+    dd: VdomDictConstructor
+    del_: VdomDictConstructor
+    details: VdomDictConstructor
+    dialog: VdomDictConstructor
+    div: VdomDictConstructor
+    dl: VdomDictConstructor
+    dt: VdomDictConstructor
+    em: VdomDictConstructor
+    embed: VdomDictConstructor
+    fieldset: VdomDictConstructor
+    figcaption: VdomDictConstructor
+    figure: VdomDictConstructor
+    footer: VdomDictConstructor
+    form: VdomDictConstructor
+    h1: VdomDictConstructor
+    h2: VdomDictConstructor
+    h3: VdomDictConstructor
+    h4: VdomDictConstructor
+    h5: VdomDictConstructor
+    h6: VdomDictConstructor
+    head: VdomDictConstructor
+    header: VdomDictConstructor
+    hr: VdomDictConstructor
+    html: VdomDictConstructor
+    i: VdomDictConstructor
+    iframe: VdomDictConstructor
+    img: VdomDictConstructor
+    input: VdomDictConstructor
+    ins: VdomDictConstructor
+    kbd: VdomDictConstructor
+    label: VdomDictConstructor
+    legend: VdomDictConstructor
+    li: VdomDictConstructor
+    link: VdomDictConstructor
+    main: VdomDictConstructor
+    map: VdomDictConstructor
+    mark: VdomDictConstructor
+    math: VdomDictConstructor
+    menu: VdomDictConstructor
+    menuitem: VdomDictConstructor
+    meta: VdomDictConstructor
+    meter: VdomDictConstructor
+    nav: VdomDictConstructor
+    noscript: VdomDictConstructor
+    object: VdomDictConstructor
+    ol: VdomDictConstructor
+    option: VdomDictConstructor
+    output: VdomDictConstructor
+    p: VdomDictConstructor
+    param: VdomDictConstructor
+    picture: VdomDictConstructor
+    portal: VdomDictConstructor
+    pre: VdomDictConstructor
+    progress: VdomDictConstructor
+    q: VdomDictConstructor
+    rp: VdomDictConstructor
+    rt: VdomDictConstructor
+    ruby: VdomDictConstructor
+    s: VdomDictConstructor
+    samp: VdomDictConstructor
+    script: VdomDictConstructor
+    section: VdomDictConstructor
+    select: VdomDictConstructor
+    slot: VdomDictConstructor
+    small: VdomDictConstructor
+    source: VdomDictConstructor
+    span: VdomDictConstructor
+    strong: VdomDictConstructor
+    style: VdomDictConstructor
+    sub: VdomDictConstructor
+    summary: VdomDictConstructor
+    sup: VdomDictConstructor
+    table: VdomDictConstructor
+    tbody: VdomDictConstructor
+    td: VdomDictConstructor
+    template: VdomDictConstructor
+    textarea: VdomDictConstructor
+    tfoot: VdomDictConstructor
+    th: VdomDictConstructor
+    thead: VdomDictConstructor
+    time: VdomDictConstructor
+    title: VdomDictConstructor
+    tr: VdomDictConstructor
+    track: VdomDictConstructor
+    u: VdomDictConstructor
+    ul: VdomDictConstructor
+    var: VdomDictConstructor
+    video: VdomDictConstructor
+    wbr: VdomDictConstructor
+    fragment: VdomDictConstructor
+
+    # Special Case: SVG elements
+    # Since SVG elements have a different set of allowed children, they are
+    # separated into a different constructor, and are accessed via `html.svg.example()`
+    svg: SvgConstructor = SvgConstructor()
+
+
+html = HtmlConstructor()
diff --git a/src/reactpy/backend/_common.py b/src/reactpy/backend/_common.py
index ac5d422aa..1e369a26b 100644
--- a/src/reactpy/backend/_common.py
+++ b/src/reactpy/backend/_common.py
@@ -109,7 +109,7 @@ def vdom_head_elements_to_html(head: Sequence[VdomDict] | VdomDict | str) -> str
             head = cast(VdomDict, {**head, "tagName": ""})
         return vdom_to_html(head)
     else:
-        return vdom_to_html(html._(*head))
+        return vdom_to_html(html.fragment(*head))
 
 
 @dataclass
diff --git a/src/reactpy/html.py b/src/reactpy/html.py
deleted file mode 100644
index 91d73d240..000000000
--- a/src/reactpy/html.py
+++ /dev/null
@@ -1,500 +0,0 @@
-"""
-
-**Fragment**
-
-- :func:`_`
-
-**Document metadata**
-
-- :func:`base`
-- :func:`head`
-- :func:`link`
-- :func:`meta`
-- :func:`style`
-- :func:`title`
-
-**Content sectioning**
-
-- :func:`address`
-- :func:`article`
-- :func:`aside`
-- :func:`footer`
-- :func:`header`
-- :func:`h1`
-- :func:`h2`
-- :func:`h3`
-- :func:`h4`
-- :func:`h5`
-- :func:`h6`
-- :func:`main`
-- :func:`nav`
-- :func:`section`
-
-**Text content**
-
-- :func:`blockquote`
-- :func:`dd`
-- :func:`div`
-- :func:`dl`
-- :func:`dt`
-- :func:`figcaption`
-- :func:`figure`
-- :func:`hr`
-- :func:`li`
-- :func:`ol`
-- :func:`p`
-- :func:`pre`
-- :func:`ul`
-
-**Inline text semantics**
-
-- :func:`a`
-- :func:`abbr`
-- :func:`b`
-- :func:`bdi`
-- :func:`bdo`
-- :func:`br`
-- :func:`cite`
-- :func:`code`
-- :func:`data`
-- :func:`em`
-- :func:`i`
-- :func:`kbd`
-- :func:`mark`
-- :func:`q`
-- :func:`rp`
-- :func:`rt`
-- :func:`ruby`
-- :func:`s`
-- :func:`samp`
-- :func:`small`
-- :func:`span`
-- :func:`strong`
-- :func:`sub`
-- :func:`sup`
-- :func:`time`
-- :func:`u`
-- :func:`var`
-- :func:`wbr`
-
-**Image and video**
-
-- :func:`area`
-- :func:`audio`
-- :func:`img`
-- :func:`map`
-- :func:`track`
-- :func:`video`
-
-**Embedded content**
-
-- :func:`embed`
-- :func:`iframe`
-- :func:`object`
-- :func:`param`
-- :func:`picture`
-- :func:`portal`
-- :func:`source`
-
-**SVG and MathML**
-
-- :func:`svg`
-- :func:`math`
-
-**Scripting**
-
-- :func:`canvas`
-- :func:`noscript`
-- :func:`script`
-
-**Demarcating edits**
-
-- :func:`del_`
-- :func:`ins`
-
-**Table content**
-
-- :func:`caption`
-- :func:`col`
-- :func:`colgroup`
-- :func:`table`
-- :func:`tbody`
-- :func:`td`
-- :func:`tfoot`
-- :func:`th`
-- :func:`thead`
-- :func:`tr`
-
-**Forms**
-
-- :func:`button`
-- :func:`fieldset`
-- :func:`form`
-- :func:`input`
-- :func:`label`
-- :func:`legend`
-- :func:`meter`
-- :func:`option`
-- :func:`output`
-- :func:`progress`
-- :func:`select`
-- :func:`textarea`
-
-**Interactive elements**
-
-- :func:`details`
-- :func:`dialog`
-- :func:`menu`
-- :func:`menuitem`
-- :func:`summary`
-
-**Web components**
-
-- :func:`slot`
-- :func:`template`
-
-.. autofunction:: _
-"""
-
-from __future__ import annotations
-
-from collections.abc import Sequence
-
-from reactpy.core.types import (
-    EventHandlerDict,
-    Key,
-    VdomAttributes,
-    VdomChild,
-    VdomDict,
-)
-from reactpy.core.vdom import custom_vdom_constructor, make_vdom_constructor
-
-__all__ = (
-    "_",
-    "a",
-    "abbr",
-    "address",
-    "area",
-    "article",
-    "aside",
-    "audio",
-    "b",
-    "base",
-    "bdi",
-    "bdo",
-    "blockquote",
-    "br",
-    "button",
-    "canvas",
-    "caption",
-    "cite",
-    "code",
-    "col",
-    "colgroup",
-    "data",
-    "dd",
-    "del_",
-    "details",
-    "dialog",
-    "div",
-    "dl",
-    "dt",
-    "em",
-    "embed",
-    "fieldset",
-    "figcaption",
-    "figure",
-    "footer",
-    "form",
-    "h1",
-    "h2",
-    "h3",
-    "h4",
-    "h5",
-    "h6",
-    "head",
-    "header",
-    "hr",
-    "i",
-    "iframe",
-    "img",
-    "input",
-    "ins",
-    "kbd",
-    "label",
-    "legend",
-    "li",
-    "link",
-    "main",
-    "map",
-    "mark",
-    "math",
-    "menu",
-    "menuitem",
-    "meta",
-    "meter",
-    "nav",
-    "noscript",
-    "object",
-    "ol",
-    "option",
-    "output",
-    "p",
-    "param",
-    "picture",
-    "portal",
-    "pre",
-    "progress",
-    "q",
-    "rp",
-    "rt",
-    "ruby",
-    "s",
-    "samp",
-    "script",
-    "section",
-    "select",
-    "slot",
-    "small",
-    "source",
-    "span",
-    "strong",
-    "style",
-    "sub",
-    "summary",
-    "sup",
-    "svg",
-    "table",
-    "tbody",
-    "td",
-    "template",
-    "textarea",
-    "tfoot",
-    "th",
-    "thead",
-    "time",
-    "title",
-    "tr",
-    "track",
-    "u",
-    "ul",
-    "var",
-    "video",
-    "wbr",
-)
-
-
-def _fragment(
-    attributes: VdomAttributes,
-    children: Sequence[VdomChild],
-    key: Key | None,
-    event_handlers: EventHandlerDict,
-) -> VdomDict:
-    """An HTML fragment - this element will not appear in the DOM"""
-    if attributes or event_handlers:
-        msg = "Fragments cannot have attributes besides 'key'"
-        raise TypeError(msg)
-    model: VdomDict = {"tagName": ""}
-
-    if children:
-        model["children"] = children
-
-    if key is not None:
-        model["key"] = key
-
-    return model
-
-
-# FIXME: https://github.com/PyCQA/pylint/issues/5784
-_ = custom_vdom_constructor(_fragment)
-
-
-# Document metadata
-base = make_vdom_constructor("base")
-head = make_vdom_constructor("head")
-link = make_vdom_constructor("link")
-meta = make_vdom_constructor("meta")
-style = make_vdom_constructor("style")
-title = make_vdom_constructor("title")
-
-# Content sectioning
-address = make_vdom_constructor("address")
-article = make_vdom_constructor("article")
-aside = make_vdom_constructor("aside")
-footer = make_vdom_constructor("footer")
-header = make_vdom_constructor("header")
-h1 = make_vdom_constructor("h1")
-h2 = make_vdom_constructor("h2")
-h3 = make_vdom_constructor("h3")
-h4 = make_vdom_constructor("h4")
-h5 = make_vdom_constructor("h5")
-h6 = make_vdom_constructor("h6")
-main = make_vdom_constructor("main")
-nav = make_vdom_constructor("nav")
-section = make_vdom_constructor("section")
-
-# Text content
-blockquote = make_vdom_constructor("blockquote")
-dd = make_vdom_constructor("dd")
-div = make_vdom_constructor("div")
-dl = make_vdom_constructor("dl")
-dt = make_vdom_constructor("dt")
-figcaption = make_vdom_constructor("figcaption")
-figure = make_vdom_constructor("figure")
-hr = make_vdom_constructor("hr", allow_children=False)
-li = make_vdom_constructor("li")
-ol = make_vdom_constructor("ol")
-p = make_vdom_constructor("p")
-pre = make_vdom_constructor("pre")
-ul = make_vdom_constructor("ul")
-
-# Inline text semantics
-a = make_vdom_constructor("a")
-abbr = make_vdom_constructor("abbr")
-b = make_vdom_constructor("b")
-bdi = make_vdom_constructor("bdi")
-bdo = make_vdom_constructor("bdo")
-br = make_vdom_constructor("br", allow_children=False)
-cite = make_vdom_constructor("cite")
-code = make_vdom_constructor("code")
-data = make_vdom_constructor("data")
-em = make_vdom_constructor("em")
-i = make_vdom_constructor("i")
-kbd = make_vdom_constructor("kbd")
-mark = make_vdom_constructor("mark")
-q = make_vdom_constructor("q")
-rp = make_vdom_constructor("rp")
-rt = make_vdom_constructor("rt")
-ruby = make_vdom_constructor("ruby")
-s = make_vdom_constructor("s")
-samp = make_vdom_constructor("samp")
-small = make_vdom_constructor("small")
-span = make_vdom_constructor("span")
-strong = make_vdom_constructor("strong")
-sub = make_vdom_constructor("sub")
-sup = make_vdom_constructor("sup")
-time = make_vdom_constructor("time")
-u = make_vdom_constructor("u")
-var = make_vdom_constructor("var")
-wbr = make_vdom_constructor("wbr")
-
-# Image and video
-area = make_vdom_constructor("area", allow_children=False)
-audio = make_vdom_constructor("audio")
-img = make_vdom_constructor("img", allow_children=False)
-map = make_vdom_constructor("map")  # noqa: A001
-track = make_vdom_constructor("track")
-video = make_vdom_constructor("video")
-
-# Embedded content
-embed = make_vdom_constructor("embed", allow_children=False)
-iframe = make_vdom_constructor("iframe", allow_children=False)
-object = make_vdom_constructor("object")  # noqa: A001
-param = make_vdom_constructor("param")
-picture = make_vdom_constructor("picture")
-portal = make_vdom_constructor("portal", allow_children=False)
-source = make_vdom_constructor("source", allow_children=False)
-
-# SVG and MathML
-svg = make_vdom_constructor("svg")
-math = make_vdom_constructor("math")
-
-# Scripting
-canvas = make_vdom_constructor("canvas")
-noscript = make_vdom_constructor("noscript")
-
-
-def _script(
-    attributes: VdomAttributes,
-    children: Sequence[VdomChild],
-    key: Key | None,
-    event_handlers: EventHandlerDict,
-) -> VdomDict:
-    """Create a new `<script> <https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script>`__ element.
-
-    .. warning::
-
-        Be careful to sanitize data from untrusted sources before using it in a script.
-        See the "Notes" for more details
-
-    This behaves slightly differently than a normal script element in that it may be run
-    multiple times if its key changes (depending on specific browser behaviors). If no
-    key is given, the key is inferred to be the content of the script or, lastly its
-    'src' attribute if that is given.
-
-    Notes:
-        Do not use unsanitized data from untrusted sources anywhere in your script.
-        Doing so may allow for malicious code injection
-        (`XSS <https://en.wikipedia.org/wiki/Cross-site_scripting>`__`).
-    """
-    model: VdomDict = {"tagName": "script"}
-
-    if event_handlers:
-        msg = "'script' elements do not support event handlers"
-        raise ValueError(msg)
-
-    if children:
-        if len(children) > 1:
-            msg = "'script' nodes may have, at most, one child."
-            raise ValueError(msg)
-        if not isinstance(children[0], str):
-            msg = "The child of a 'script' must be a string."
-            raise ValueError(msg)
-        model["children"] = children
-        if key is None:
-            key = children[0]
-
-    if attributes:
-        model["attributes"] = attributes
-        if key is None and not children and "src" in attributes:
-            key = attributes["src"]
-
-    if key is not None:
-        model["key"] = key
-
-    return model
-
-
-# FIXME: https://github.com/PyCQA/pylint/issues/5784
-script = custom_vdom_constructor(_script)
-
-# Demarcating edits
-del_ = make_vdom_constructor("del")
-ins = make_vdom_constructor("ins")
-
-# Table content
-caption = make_vdom_constructor("caption")
-col = make_vdom_constructor("col")
-colgroup = make_vdom_constructor("colgroup")
-table = make_vdom_constructor("table")
-tbody = make_vdom_constructor("tbody")
-td = make_vdom_constructor("td")
-tfoot = make_vdom_constructor("tfoot")
-th = make_vdom_constructor("th")
-thead = make_vdom_constructor("thead")
-tr = make_vdom_constructor("tr")
-
-# Forms
-button = make_vdom_constructor("button")
-fieldset = make_vdom_constructor("fieldset")
-form = make_vdom_constructor("form")
-input = make_vdom_constructor("input", allow_children=False)  # noqa: A001
-label = make_vdom_constructor("label")
-legend = make_vdom_constructor("legend")
-meter = make_vdom_constructor("meter")
-option = make_vdom_constructor("option")
-output = make_vdom_constructor("output")
-progress = make_vdom_constructor("progress")
-select = make_vdom_constructor("select")
-textarea = make_vdom_constructor("textarea")
-
-# Interactive elements
-details = make_vdom_constructor("details")
-dialog = make_vdom_constructor("dialog")
-menu = make_vdom_constructor("menu")
-menuitem = make_vdom_constructor("menuitem")
-summary = make_vdom_constructor("summary")
-
-# Web components
-slot = make_vdom_constructor("slot")
-template = make_vdom_constructor("template")
diff --git a/src/reactpy/svg.py b/src/reactpy/svg.py
deleted file mode 100644
index ebfe58ee6..000000000
--- a/src/reactpy/svg.py
+++ /dev/null
@@ -1,139 +0,0 @@
-from reactpy.core.vdom import make_vdom_constructor
-
-__all__ = (
-    "a",
-    "animate",
-    "animate_motion",
-    "animate_transform",
-    "circle",
-    "clip_path",
-    "defs",
-    "desc",
-    "discard",
-    "ellipse",
-    "fe_blend",
-    "fe_color_matrix",
-    "fe_component_transfer",
-    "fe_composite",
-    "fe_convolve_matrix",
-    "fe_diffuse_lighting",
-    "fe_displacement_map",
-    "fe_distant_light",
-    "fe_drop_shadow",
-    "fe_flood",
-    "fe_func_a",
-    "fe_func_b",
-    "fe_func_g",
-    "fe_func_r",
-    "fe_gaussian_blur",
-    "fe_image",
-    "fe_merge",
-    "fe_merge_node",
-    "fe_morphology",
-    "fe_offset",
-    "fe_point_light",
-    "fe_specular_lighting",
-    "fe_spot_light",
-    "fe_tile",
-    "fe_turbulence",
-    "filter",
-    "foreign_object",
-    "g",
-    "hatch",
-    "hatchpath",
-    "image",
-    "line",
-    "linear_gradient",
-    "marker",
-    "mask",
-    "metadata",
-    "mpath",
-    "path",
-    "pattern",
-    "polygon",
-    "polyline",
-    "radial_gradient",
-    "rect",
-    "script",
-    "set",
-    "stop",
-    "style",
-    "svg",
-    "switch",
-    "symbol",
-    "text",
-    "text_path",
-    "title",
-    "tspan",
-    "use",
-    "view",
-)
-
-a = make_vdom_constructor("a")
-animate = make_vdom_constructor("animate", allow_children=False)
-animate_motion = make_vdom_constructor("animateMotion", allow_children=False)
-animate_transform = make_vdom_constructor("animateTransform", allow_children=False)
-circle = make_vdom_constructor("circle", allow_children=False)
-clip_path = make_vdom_constructor("clipPath")
-defs = make_vdom_constructor("defs")
-desc = make_vdom_constructor("desc", allow_children=False)
-discard = make_vdom_constructor("discard", allow_children=False)
-ellipse = make_vdom_constructor("ellipse", allow_children=False)
-fe_blend = make_vdom_constructor("feBlend", allow_children=False)
-fe_color_matrix = make_vdom_constructor("feColorMatrix", allow_children=False)
-fe_component_transfer = make_vdom_constructor(
-    "feComponentTransfer", allow_children=False
-)
-fe_composite = make_vdom_constructor("feComposite", allow_children=False)
-fe_convolve_matrix = make_vdom_constructor("feConvolveMatrix", allow_children=False)
-fe_diffuse_lighting = make_vdom_constructor("feDiffuseLighting", allow_children=False)
-fe_displacement_map = make_vdom_constructor("feDisplacementMap", allow_children=False)
-fe_distant_light = make_vdom_constructor("feDistantLight", allow_children=False)
-fe_drop_shadow = make_vdom_constructor("feDropShadow", allow_children=False)
-fe_flood = make_vdom_constructor("feFlood", allow_children=False)
-fe_func_a = make_vdom_constructor("feFuncA", allow_children=False)
-fe_func_b = make_vdom_constructor("feFuncB", allow_children=False)
-fe_func_g = make_vdom_constructor("feFuncG", allow_children=False)
-fe_func_r = make_vdom_constructor("feFuncR", allow_children=False)
-fe_gaussian_blur = make_vdom_constructor("feGaussianBlur", allow_children=False)
-fe_image = make_vdom_constructor("feImage", allow_children=False)
-fe_merge = make_vdom_constructor("feMerge", allow_children=False)
-fe_merge_node = make_vdom_constructor("feMergeNode", allow_children=False)
-fe_morphology = make_vdom_constructor("feMorphology", allow_children=False)
-fe_offset = make_vdom_constructor("feOffset", allow_children=False)
-fe_point_light = make_vdom_constructor("fePointLight", allow_children=False)
-fe_specular_lighting = make_vdom_constructor("feSpecularLighting", allow_children=False)
-fe_spot_light = make_vdom_constructor("feSpotLight", allow_children=False)
-fe_tile = make_vdom_constructor("feTile", allow_children=False)
-fe_turbulence = make_vdom_constructor("feTurbulence", allow_children=False)
-filter = make_vdom_constructor("filter", allow_children=False)  # noqa: A001
-foreign_object = make_vdom_constructor("foreignObject", allow_children=False)
-g = make_vdom_constructor("g")
-hatch = make_vdom_constructor("hatch", allow_children=False)
-hatchpath = make_vdom_constructor("hatchpath", allow_children=False)
-image = make_vdom_constructor("image", allow_children=False)
-line = make_vdom_constructor("line", allow_children=False)
-linear_gradient = make_vdom_constructor("linearGradient", allow_children=False)
-marker = make_vdom_constructor("marker")
-mask = make_vdom_constructor("mask")
-metadata = make_vdom_constructor("metadata", allow_children=False)
-mpath = make_vdom_constructor("mpath", allow_children=False)
-path = make_vdom_constructor("path", allow_children=False)
-pattern = make_vdom_constructor("pattern")
-polygon = make_vdom_constructor("polygon", allow_children=False)
-polyline = make_vdom_constructor("polyline", allow_children=False)
-radial_gradient = make_vdom_constructor("radialGradient", allow_children=False)
-rect = make_vdom_constructor("rect", allow_children=False)
-script = make_vdom_constructor("script", allow_children=False)
-set = make_vdom_constructor("set", allow_children=False)  # noqa: A001
-stop = make_vdom_constructor("stop", allow_children=False)
-style = make_vdom_constructor("style", allow_children=False)
-svg = make_vdom_constructor("svg")
-switch = make_vdom_constructor("switch")
-symbol = make_vdom_constructor("symbol")
-text = make_vdom_constructor("text", allow_children=False)
-text_path = make_vdom_constructor("textPath", allow_children=False)
-title = make_vdom_constructor("title", allow_children=False)
-tspan = make_vdom_constructor("tspan", allow_children=False)
-use = make_vdom_constructor("use", allow_children=False)
-view = make_vdom_constructor("view", allow_children=False)
diff --git a/src/reactpy/widgets.py b/src/reactpy/widgets.py
index 63b45a7e0..92676b92f 100644
--- a/src/reactpy/widgets.py
+++ b/src/reactpy/widgets.py
@@ -5,7 +5,7 @@
 from typing import TYPE_CHECKING, Any, Callable, Protocol, TypeVar
 
 import reactpy
-from reactpy import html
+from reactpy._html import html
 from reactpy._warnings import warn
 from reactpy.core.types import ComponentConstructor, VdomDict
 
diff --git a/src/reactpy/sample.py b/tests/sample.py
similarity index 100%
rename from src/reactpy/sample.py
rename to tests/sample.py
diff --git a/tests/test_backend/test_common.py b/tests/test_backend/test_common.py
index 248bf9451..1f40c96cf 100644
--- a/tests/test_backend/test_common.py
+++ b/tests/test_backend/test_common.py
@@ -51,7 +51,7 @@ def test_catch_unsafe_relative_path_traversal(tmp_path, bad_path):
             '<meta charset="utf-8"><title>example</title>',
         ),
         (
-            html._(
+            html.fragment(
                 html.meta({"charset": "utf-8"}),
                 html.title("example"),
             ),
diff --git a/tests/test_backend/test_utils.py b/tests/test_backend/test_utils.py
index 2a58dc62a..319dd816f 100644
--- a/tests/test_backend/test_utils.py
+++ b/tests/test_backend/test_utils.py
@@ -8,7 +8,7 @@
 from reactpy.backend import flask as flask_implementation
 from reactpy.backend.utils import find_available_port
 from reactpy.backend.utils import run as sync_run
-from reactpy.sample import SampleApp
+from tests.sample import SampleApp
 
 
 @pytest.fixture
diff --git a/tests/test_client.py b/tests/test_client.py
index a9ff10a89..ea7ebcb6b 100644
--- a/tests/test_client.py
+++ b/tests/test_client.py
@@ -23,7 +23,7 @@ async def test_automatic_reconnect(browser: Browser):
     @reactpy.component
     def SomeComponent():
         count, incr_count = use_counter(0)
-        return reactpy.html._(
+        return reactpy.html.fragment(
             reactpy.html.p({"data_count": count, "id": "count"}, "count", count),
             reactpy.html.button(
                 {"on_click": lambda e: incr_count(), "id": "incr"}, "incr"
diff --git a/tests/test_console/test_rewrite_keys.py b/tests/test_console/test_rewrite_keys.py
index 01feb34c3..159bdb654 100644
--- a/tests/test_console/test_rewrite_keys.py
+++ b/tests/test_console/test_rewrite_keys.py
@@ -61,14 +61,6 @@ def test_rewrite_key_declarations_no_files():
             "vdom('div', {'some_attr': 1}, child_1, child_2, key='test')",
             "vdom('div', {'some_attr': 1, 'key': 'test'}, child_1, child_2)",
         ),
-        (
-            "html.div(dict(some_attr=1), child_1, child_2, key='test')",
-            "html.div(dict(some_attr=1, key='test'), child_1, child_2)",
-        ),
-        (
-            "vdom('div', dict(some_attr=1), child_1, child_2, key='test')",
-            "vdom('div', dict(some_attr=1, key='test'), child_1, child_2)",
-        ),
         # avoid unnecessary changes
         (
             """
@@ -186,10 +178,6 @@ def func():
             """,
         ),
         # no rewrites
-        (
-            "html.no_an_element(key='test')",
-            None,
-        ),
         (
             "not_html.div(key='test')",
             None,
diff --git a/tests/test_core/test_hooks.py b/tests/test_core/test_hooks.py
index 5b8f71c62..550d35cbc 100644
--- a/tests/test_core/test_hooks.py
+++ b/tests/test_core/test_hooks.py
@@ -979,7 +979,7 @@ async def test_context_values_are_scoped():
 
     @reactpy.component
     def Parent():
-        return html._(
+        return html.fragment(
             Context(Context(Child1(), value=1), value="something-else"),
             Context(Child2(), value=2),
         )
diff --git a/tests/test_core/test_layout.py b/tests/test_core/test_layout.py
index 96f495ebe..f86a80cd2 100644
--- a/tests/test_core/test_layout.py
+++ b/tests/test_core/test_layout.py
@@ -1224,7 +1224,7 @@ def colorize(event):
     @component
     def App():
         items = use_state(["A", "B", "C"])
-        return html._([Item(item, items, key=item) for item in items.value])
+        return html.fragment([Item(item, items, key=item) for item in items.value])
 
     async with layout_runner(reactpy.Layout(App())) as runner:
         tree = await runner.render()
@@ -1265,7 +1265,7 @@ async def test_async_renders(async_rendering):
 
     @component
     def outer():
-        return html._(child_1(), child_2())
+        return html.fragment(child_1(), child_2())
 
     @component
     @child_1_hook.capture
diff --git a/tests/test_html.py b/tests/test_html.py
index 30b02ce99..aa541dedf 100644
--- a/tests/test_html.py
+++ b/tests/test_html.py
@@ -88,10 +88,10 @@ def test_script_has_no_event_handlers():
 
 
 def test_simple_fragment():
-    assert html._() == {"tagName": ""}
-    assert html._(1, 2, 3) == {"tagName": "", "children": [1, 2, 3]}
-    assert html._({"key": "something"}) == {"tagName": "", "key": "something"}
-    assert html._({"key": "something"}, 1, 2, 3) == {
+    assert html.fragment() == {"tagName": ""}
+    assert html.fragment(1, 2, 3) == {"tagName": "", "children": [1, 2, 3]}
+    assert html.fragment({"key": "something"}) == {"tagName": "", "key": "something"}
+    assert html.fragment({"key": "something"}, 1, 2, 3) == {
         "tagName": "",
         "key": "something",
         "children": [1, 2, 3],
@@ -100,4 +100,4 @@ def test_simple_fragment():
 
 def test_fragment_can_have_no_attributes():
     with pytest.raises(TypeError, match="Fragments cannot have attributes"):
-        html._({"some_attribute": 1})
+        html.fragment({"some_attribute": 1})
diff --git a/tests/test_sample.py b/tests/test_sample.py
index b92e89789..1e6654c0e 100644
--- a/tests/test_sample.py
+++ b/tests/test_sample.py
@@ -1,5 +1,5 @@
-from reactpy.sample import SampleApp
 from reactpy.testing import DisplayFixture
+from tests.sample import SampleApp
 
 
 async def test_sample_app(display: DisplayFixture):
diff --git a/tests/test_testing.py b/tests/test_testing.py
index 68e36e7f6..63439c194 100644
--- a/tests/test_testing.py
+++ b/tests/test_testing.py
@@ -6,9 +6,9 @@
 from reactpy import Ref, component, html, testing
 from reactpy.backend import starlette as starlette_implementation
 from reactpy.logging import ROOT_LOGGER
-from reactpy.sample import SampleApp
 from reactpy.testing.backend import _hotswap
 from reactpy.testing.display import DisplayFixture
+from tests.sample import SampleApp
 
 
 def test_assert_reactpy_logged_does_not_suppress_errors():
diff --git a/tests/test_utils.py b/tests/test_utils.py
index ca3080358..b071fdc9f 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -215,11 +215,11 @@ def test_del_html_body_transform():
             "<button></button>",
         ),
         (
-            html._("hello ", html._("world")),
+            html.fragment("hello ", html.fragment("world")),
             "hello world",
         ),
         (
-            html._(html.div("hello"), html._("world")),
+            html.fragment(html.div("hello"), html.fragment("world")),
             "<div>hello</div>world",
         ),
         (
@@ -231,7 +231,7 @@ def test_del_html_body_transform():
             '<div style="background-color:blue;margin-left:10px"></div>',
         ),
         (
-            html._(
+            html.fragment(
                 html.div("hello"),
                 html.a({"href": "https://example.com"}, "example"),
             ),
@@ -239,7 +239,7 @@ def test_del_html_body_transform():
         ),
         (
             html.div(
-                html._(
+                html.fragment(
                     html.div("hello"),
                     html.a({"href": "https://example.com"}, "example"),
                 ),