Channels4World

An environment-scale foundation for wireless AI. Channels4World is a ray-traced wireless channel dataset for learning across many environments, from wireless foundation models to channel prediction and localization: 100,000 synthetic outdoor scenes, each with 32 base stations (BSs) and 16,384 UE positions, simulated at 3.5 and 7 GHz with Sionna RT. Scenes come from three generation profiles (urban, metropolitan and suburban). Train and test are split by scene, and nested tiers from 200 to 100,000 scenes let you scale the number of environments separately from the data in each.

Get data: Choose a subset and get download commands (Space) · 26 MB starter: one Tiny scene

Example scenes from the three profiles. Building colours show material classes.

Release 1.0.0	Coverage
Geometry and positions	All 100,000 scenes
Core channels	All 100,000 scenes, both carriers
Detail (interactions)	The 10,000 Medium-tier scenes, both carriers
Total	About 20.8 TB: the Full tier, the loose Tiny copy and metadata

Access: Geometry, positions and core channels for all 100,000 scenes are hosted on Hugging Face. Interaction detail exists for the full corpus; Hugging Face currently hosts the 10,000 Medium-tier scenes, including Tiny and Small. Interaction detail for the remaining scenes is currently unavailable for direct download. Contact the project lead about access.

Start with plain NumPy, use the channels4world library to select larger subsets, or read the TAR archives with 🤗 Datasets. Numeric records are standard NPZ files; geometry is ZIP. Every example follows one link: BS 0 and UE 14 of urban_scene_019234 at 3.5 GHz, the link the project website shows.

Project website · Library source on GitHub · Paper (submitted; arXiv preprint pending) · Tutorials · Schema reference · Library guide · Without the library

Contents

Each scene is divided into four components, which you can download separately.

urban_scene_019234 at 3.5 GHz, top view (heights not shown). UE positions are a sample of the 16,384. Each path segment takes the colour of the interaction it leaves.

Component	What it holds	One file per	Files per scene
geometry	The 3-D scene: Mitsuba XML and OBJ meshes	scene	1
positions	Coordinates of the 32 BSs and 16,384 UEs	scene	1
core	Every retained path from one BS to each UE it reaches: gain, delay, angles, interaction count and type flags	scene × carrier × BS	64
detail	Each path's interactions in order: type and location	scene × carrier × BS	64

Geometry and positions are shared by both carriers; core and detail are frequency-specific. Most channel work needs only positions and core.

What a record keeps. Each link keeps at most the 16 strongest paths whose power exceeds −150 dB, ordered by decreasing power (computed in float32). Paths combine line of sight, specular reflection and diffraction, with up to four interactions per path; diffuse reflection and refraction are not modeled. A UE with no stored link to a BS has no retained path to it; that is not a zero-power channel. The scenes are synthetic and the channels are simulated, not measured; the paper describes how they were generated.

Gains are the passband coefficients without the carrier-delay phase, relative to unit power. Angles: zenith from +z, azimuth from +x toward +y. Each BS and UE has one isotropic, vertically polarized antenna, already included in the gains. Details: schema reference.

How the files connect

Illustrative values: link 0 is UE 2 and owns paths 0–1; link 1 is UE 9 and owns path 2.

• One frame: geometry, positions and interaction vertices share scene coordinates in metres.
• BS: the number in a file name (bs00000) is its row in bs_positions.
• UE: each value of link_ue_index is a row in ue_positions. A UE that isn't listed has no retained link to this BS (not a zero-power channel).
• Paths: link ℓ owns paths link_path_offsets[ℓ] to link_path_offsets[ℓ+1] (end excluded).
• Interactions: detail lists paths in core's order; path p owns interactions path_interaction_offsets[p] to [p+1].

Arrays in each file

L links, P paths and I interactions vary per record. For example, BS 0 of urban_scene_019234 at 3.5 GHz has L = 15,873 retained links and P = 214,443 paths.

geometry · geometry.zip: scene.json names the entry XML, which references OBJ meshes in metres.

positions · positions.npz

Array	Shape	Type	Meaning
bs_positions	32 × 3	float32	BS coordinates, m
ue_positions	16,384 × 3	float32	UE coordinates, m

core · band_hz=<Hz>/component=core/bs<NNNNN>.npz

Array	Shape	Type	Meaning
link_ue_index	L	int32	UE ID of each link, ascending
link_path_offsets	L + 1	int64	Where each link's paths start and end
a_real, a_imag	P	float32	Complex path gain
tau	P	float32	Delay, s
theta_t, phi_t	P	float32	Departure angles at the BS, rad
theta_r, phi_r	P	float32	Arrival angles at the UE, rad
interaction_count	P	uint8	Number of interactions
interaction_flags	P	uint16	Interaction types present, one bit per type
path_rank	P	uint8	0-based position within its link, by decreasing float32 power

detail · same name under component=detail

Array	Shape	Type	Meaning
path_interaction_offsets	P + 1	int64	Where each path's interactions start and end
interaction_type	I	int8	1 specular reflection, 8 diffraction (2 diffuse reflection and 4 refraction are defined but not modeled)
interaction_rank	I	uint8	0-based position along the path
interaction_vertex	I × 3	float32	Location, m

Organization

Every scene belongs to one split (train or test) and one profile (urban, metropolitan or suburban). Scenes are offered in nested tiers, so a larger tier keeps every scene of the smaller ones. Every tier is 90% train and 10% test, and within each split 50% urban, 25% metropolitan and 25% suburban.

Tier	Train urban	Train metropolitan	Train suburban	Test urban	Test metropolitan	Test suburban	Total
Tiny	90	45	45	10	5	5	200
Small	450	225	225	50	25	25	1,000
Medium	4,500	2,250	2,250	500	250	250	10,000
Large	22,500	11,250	11,250	2,500	1,250	1,250	50,000
Full	45,000	22,500	22,500	5,000	2,500	2,500	100,000

• A scene is in exactly one split. Both carriers and all four components of a scene share it.
• There is no validation split. Hold out training scenes by scene, not by link or UE.
• In the catalog, tier is the smallest tier that contains a scene. Medium is therefore tier in {"tiny", "small", "medium"}.

Tier	Core	Detail	Geometry + positions	Total
Tiny	38.9 GB	26.7 GB	41 MB	65.6 GB
Small	194 GB	133 GB	207 MB	327 GB
Medium	1.93 TB	1.32 TB	2.07 GB	3.26 TB
Large	9.66 TB	1.32 TB (Medium only)	10.3 GB	10.99 TB
Full	19.32 TB	1.32 TB (Medium only)	20.7 GB	20.66 TB

Sizes cover both carriers (GB = 10⁹ bytes, TB = 10¹² bytes); catalogs and group metadata add under 0.2%. Tiny is published as loose files (65.7 GB with its metadata), and its scenes are also part of Small.

The 29.14 TB reported in the paper reflects an earlier compression and packaging format. The release has since been repackaged to make the data easier to download and use.

Tiers choose scenes; components and carriers are chosen separately. Tiny needs no unpacking.

Download

Try one scene from Tiny to get loose files without unpacking. For Small or larger, download TAR archives and use the catalog to select scenes, carriers and components. Each example below leaves files under c4w/. Commands use the release tag v1.0.0; the hf command comes with huggingface_hub (pip install huggingface_hub). The download helper (also a Space) sizes any tier, split, profile, carrier and component choice and writes these commands for it.

Try one Tiny scene — 26 MB, 16 files

Download base station 0 of one scene (26.0 MB in 16 files, including the metadata the library needs):

hf download Intelligence-Networking-Lab/Channels4World --repo-type dataset \
  --revision v1.0.0 --local-dir c4w \
  --include 'tiny/c4w-root.json' --include 'tiny/c4w-root/*' --include 'tiny/schema/*' \
  --include 'tiny/groups/test-urban-g00000/catalog/members.parquet' \
  --include 'tiny/groups/test-urban-g00000/snapshot.json' \
  --include 'tiny/records/scene=urban_scene_019234/positions.npz' \
  --include 'tiny/records/scene=urban_scene_019234/geometry.zip' \
  --include 'tiny/records/scene=urban_scene_019234/band_hz=*/component=*/bs00000.npz'

For NumPy alone, the last three --include patterns are enough (15.2 MB). For all 32 BSs of the scene, replace them with --include 'tiny/records/scene=urban_scene_019234/*' (418.0 MB with the metadata). For all of Tiny, use --include 'tiny/*' (65.7 GB). For another Tiny scene, take its group from the tiny_scenes catalog. The three scenes shown on the project website, urban_scene_019234, metro_scene_054046 and suburban_scene_096016, are Tiny test scenes. Then read the data below.

Download a tier

Install the optional library with pip install channels4world (Python ≥3.11). Download the release catalog, then select Small, positions and core at 3.5 GHz:

hf download Intelligence-Networking-Lab/Channels4World --repo-type dataset \
  --revision v1.0.0 --local-dir c4w \
  --include 'c4w-root.json' --include 'c4w-root/*'

import channels4world as c4w
from huggingface_hub import snapshot_download

ds = c4w.open("c4w")
selection = ds.select(tier="small", frequencies_hz=[3_500_000_000],
                      components=("positions", "core"))
report = selection.missing()
print(report)                         # planned files and total size
if report.files:
    snapshot_download(
        "Intelligence-Networking-Lab/Channels4World", repo_type="dataset",
        revision="v1.0.0", local_dir=report.local_dir,
        allow_patterns=report.repo_files,
    )
assert selection.missing().complete

select() also takes split= and profile= (catalog spelling: urban, metropolitan, suburban). Each archive holds one group: 25 scenes of one split and profile, from one tier, with all 32 BSs. Tier, split and profile selections therefore download exactly their scenes; a list of scene IDs downloads the whole groups that contain them. selection.to_recipe() saves a selection as a small JSON recipe that others can replay with ds.select_recipe(...) or c4w missing c4w --recipe FILE; the download helper writes the same recipes. The library guide covers larger download plans, subsets and caching; without the library covers glob downloads and ordinary TAR extraction.

Select scenes and components

With the release catalog from the tier example local, choose exact scene IDs and the components you need. The catalog finds the containing archives:

import channels4world as c4w
from huggingface_hub import snapshot_download

ds = c4w.open("c4w")
selection = ds.select(scene_ids=["urban_scene_019234"],
                      frequencies_hz=[3_500_000_000], components=("positions", "core"))
report = selection.missing()
print(report)
if report.files:
    snapshot_download(
        "Intelligence-Networking-Lab/Channels4World", repo_type="dataset",
        revision="v1.0.0", local_dir=report.local_dir,
        allow_patterns=report.repo_files,
    )
assert selection.missing().complete

HF Datasets can also stream archives without downloading the entire selection first.

Read the data

We recommend the channels4world library for selection, verification and repeated reads; standard NumPy works directly with loose files. Both examples read the same link, BS 0 → UE 14 of urban_scene_019234 at 3.5 GHz: its delays, complex gains and BS–UE distance. Change the IDs at the top to read any other link you have downloaded.

Read with the library

from pathlib import Path
import numpy as np
import channels4world as c4w

TINY_ROOT = Path("c4w/tiny")
SCENE_ID, CARRIER_HZ, BS_ID, UE_ID = "urban_scene_019234", 3_500_000_000, 0, 14
ds = c4w.open(TINY_ROOT)
scene = ds.scene(SCENE_ID)
record = scene.frequencies[CARRIER_HZ].base_stations[BS_ID].read()
positions = scene.read_positions()

link = record.get_link(UE_ID)      # None when this UE has no retained link to this BS
print(link.n_paths, link.core["tau"])                        # 16 retained paths, delays in s
print(link.core["a_real"] + 1j * link.core["a_imag"])
print(np.linalg.norm(positions.ue[UE_ID] - positions.bs[BS_ID]))

The library's arrays keep the stored dtypes and are read-only. For downloaded TARs, open the release root (c4w/) and iterate your selection directly; extraction is optional. See iteration and extraction.

Read loose files with NumPy

The same code works after ordinary TAR extraction: change TINY_ROOT to the extracted folder.

from pathlib import Path
import numpy as np

TINY_ROOT = Path("c4w/tiny")
SCENE_ID, CARRIER_HZ, BS_ID, UE_ID = "urban_scene_019234", 3_500_000_000, 0, 14
scene_dir = TINY_ROOT / "records" / f"scene={SCENE_ID}"
core_path = scene_dir / f"band_hz={CARRIER_HZ}" / "component=core" / f"bs{BS_ID:05d}.npz"

with np.load(core_path, allow_pickle=False) as core, np.load(
    scene_dir / "positions.npz", allow_pickle=False
) as positions:
    ue_ids = core["link_ue_index"]             # retained UE IDs, ascending
    row = int(np.searchsorted(ue_ids, UE_ID))  # this UE's link row
    assert row < ue_ids.size and ue_ids[row] == UE_ID, "No retained link to this UE."
    start, stop = map(int, core["link_path_offsets"][row:row + 2])
    print(stop - start, core["tau"][start:stop])
    print(core["a_real"][start:stop] + 1j * core["a_imag"][start:stop])
    print(np.linalg.norm(positions["ue_positions"][UE_ID] - positions["bs_positions"][BS_ID]))

NumPy preserves the NPZ's stored dtypes and shapes. UE_ID indexes positions; row indexes retained links. Keep that mapping when filtering. Ordinary TAR extraction writes these payload paths; library extraction also creates a navigable subset root.

Pad paths to fixed-size arrays

Each link has at most 16 paths, so any per-path array becomes an (L, 16) array plus a mask. Row i belongs to UE link_ue_index[i]:

import numpy as np

def pad_paths(core, name, max_paths=16):
    """Per-path array -> (links, max_paths) array and a mask of stored paths."""
    offsets = np.asarray(core["link_path_offsets"])
    values = np.asarray(core[name])
    counts = np.diff(offsets)                                # paths per link
    rows = np.repeat(np.arange(counts.size), counts)
    cols = np.arange(offsets[-1]) - np.repeat(offsets[:-1], counts)
    padded = np.zeros((counts.size, max_paths), values.dtype)
    padded[rows, cols] = values
    mask = np.arange(max_paths) < counts[:, None]
    return padded, mask

with np.load(core_path, allow_pickle=False) as core:     # core_path from the example above
    tau, mask = pad_paths(core, "tau")                    # (L, 16) float32, (L, 16) bool
    gain = pad_paths(core, "a_real")[0] + 1j * pad_paths(core, "a_imag")[0]
    ue_ids = core["link_ue_index"]                        # (L,) row i <-> UE ue_ids[i]

Padded entries are zero; use the mask, not the value, to tell them apart. The same works on library records and on HF Datasets rows after restoring their shapes. The library has the same function, with a per-path version for interactions: from channels4world.transforms import pad_paths, pad_interactions.

Streaming archives

Stream remote TARs on demand, or iterate the same TARs saved locally without a network read. Each HF Datasets example is one BS record, not one UE or a joined scene. Archives stream in order: to reach one record, stream only the group archive that holds it.

Stream archives with 🤗 Datasets

import numpy as np
from datasets import load_dataset

SCENE_ID, BS_ID, UE_ID = "urban_scene_019234", 0, 14
archive = ("hf://datasets/Intelligence-Networking-Lab/Channels4World@v1.0.0/payload/"
           "3.5ghz/core/inc1-small/test-urban-g00000-3.5ghz-core.tar")   # this scene's group
# For a downloaded copy: archive = "c4w/payload/3.5ghz/core/inc1-small/test-urban-g00000-3.5ghz-core.tar"
member = f"records/scene={SCENE_ID}/band_hz=3500000000/component=core/bs{BS_ID:05d}"
core = load_dataset("webdataset", streaming=True, data_files={"test": archive})["test"]
record = next(r for r in core.with_format("numpy") if r["__key__"] == member)
arrays = record["npz"]                        # HF has already decoded the NPZ
row = int(np.searchsorted(arrays["link_ue_index"], UE_ID))
start, stop = map(int, arrays["link_path_offsets"][row:row + 2])
print(arrays["tau"][start:stop])              # UE 14's delays (s)

The group comes from the scenes catalog. Streaming reads the archive from its start, so the members before this record are read too (at most one group's archive). streaming=True iterates on demand; without it, HF Datasets downloads the archives and builds an Arrow dataset on disk, from remote or local input. HF formatting can change dtypes. See the HF guide for explicit features, shape and dtype restoration, and joining positions. To read one record without the rest of its archive, use a byte-range read (file guide). Tiny stays loose.

Tutorials

Each tutorial is a page and a notebook that runs top to bottom. The two reading tutorials follow the same link, BS 0 → UE 14 of urban_scene_019234.

Tutorial	Reads with	Covers
Read one scene (notebook)	the library	catalog → scene → carrier → BS → UE link → paths; geometry and positions; the stored arrays; the same link at 7 GHz
Read one scene without the library (notebook)	NumPy	the same steps on the loose files
From channel records to a DataLoader (notebook)	the library, PyTorch	link samples, train/validation/test by scene, padded arrays, preprocessing, a cache and batches

Files and catalogs

The catalogs list scenes and files so you can choose downloads and locate records; metadata supplies their identities and checksums. The dataset viewer shows three catalog configs: scenes (default; one row per scene), files (every archive, group metadata and schema file with its size and SHA-256; the root catalog files and this card are not listed) and tiny_scenes (Tiny's 200 scenes). Their split is named catalog; it is not the train/test split, which is the split column. The viewer shows catalog rows, not channel arrays. The file guide explains how to use them.

File reference

Path	What it is
c4w-root.json, c4w-root/	Release catalog: every scene (split, profile, tier, group) and every archive, metadata and schema file (path, size, checksum)
groups/<group>/	Group metadata: where each record sits inside the archives, and its identity and checksums
schema/	Interpretation documents (units, conventions, interaction codes)

c4w-root.json, c4w-root/        release catalog
schema/, groups/                interpretation documents, group metadata
payload/                        TAR archives (paths below)
tiny/                           Tiny: its own catalog, schema/, groups/ and
  records/scene=<id>/               loose files per scene:
    geometry.zip, positions.npz
    band_hz=<3500000000|7000000000>/component=<core|detail>/bs00000.npz … bs00031.npz

Archive path templates:

payload/scene/<geometry|positions>/inc<N>-<tier>/<group>-<component>.tar
payload/<3.5ghz|7ghz>/<core|detail>/inc<N>-<tier>/<group>-<band>-<component>.tar

• Groups are named <split>-<profile code>-g<NNNNN>, with profile code urban, metro or suburban (the catalog spells metro as metropolitan). Each holds exactly 25 scenes.
• Increments are inc1-small, inc2-medium, inc3-large and inc4-full. A tier is its own increment plus all smaller ones, so in every component folder Small is inc1-*, Medium inc[1-2]-*, Large inc[1-3]-* and Full inc*.
• Detail is hosted in inc1-small and inc2-medium only.

Query the catalogs

from datasets import load_dataset

REPO, REV = "Intelligence-Networking-Lab/Channels4World", "v1.0.0"
scenes = load_dataset(REPO, "scenes", split="catalog", revision=REV)
files = load_dataset(REPO, "files", split="catalog", revision=REV)
print(scenes.filter(lambda row: row["split"] == "test")[:3])
print(files.filter(lambda row: row["kind"] == "payload")[:3])

License and citation

Channels4World: CC BY 4.0. If you share or adapt it, credit Joonkyu Jang, link the license and indicate changes. channels4world library: Apache-2.0.

If Channels4World is useful in your research, please cite the dataset paper:

J. Jang, H.-J. Moon, K. S. Kim, S.-L. Kim, J. Hoydis, R. W. Heath Jr. and C.-B. Chae, "Channels4World: An Environment-Scale Dataset for Wireless Foundation Models," submitted to IEEE Transactions on Communications.

The arXiv preprint and a BibTeX entry will be added here when the preprint is available.

Item	Version
Channels4World release	1.0.0: tag v1.0.0 (the tag pins the exact repository commit)
Collection ID	channels4world-v1-20260714, in every record header; it names the generated collection, while 1.0.0 names this release
Library	channels4world 1.0.0, Python ≥3.11
Catalog format	channels4world.root version 1