ViTweb

851,994 Vietnamese documents from one public corpus, 203.5 MB of Parquet, one schema

This dataset is one row per page gao's own crawler fetched and kept: the extracted article as plain text, the same article as markdown, the whole page as markdown, and the address, host, fetch time, robots decision and every measurement the page was judged on.

Contents

• What is it
• What is in it
• Where the text came from
• How it is laid out
• Reading it
• What you can build with it
• One row
• The columns
• What this repo is
• What ships and what does not
• Things to know before you use it
• What this is not
• Citation
• Where this comes from

What is it

Vietnamese web text on the Hub is Common Crawl, three times over. fineweb-2, GlotCC and HPLT are built from overlapping snapshots of the same crawl, so the sites Common Crawl does not reach well are missing from all three at once, and Vietnamese provincial news, forums and government publishing is a good deal of what that misses.

This is gao crawling those sites itself. One row per page that was fetched and kept, carrying the page three ways: text is the article as plain prose, markdown is the same article with its headings, lists, tables and links intact, and body is the whole page as markdown before the extractor picked the article out of it. Alongside them are the URL, the host, when it was fetched, the robots rule that allowed it, the media type, and every measurement the page was judged on, including the full heuristics map the sift produced.

Three columns rather than one because they fail differently. text is what a pretraining run wants and it is the extractor's opinion about which part of the page was the article. markdown is the same opinion with the structure kept, which is what a document understanding or a retrieval corpus needs and what plain text throws away. body is not an opinion: it is the page, and it is the column to reach for when the extractor got it wrong, which it does. A bug that cost every article on one large news site its text went unnoticed for the life of the crawl, and the only reason a rerun could fix it without asking those sites for their pages a second time is that a column like body exists.

Every page that was not kept is in open-index/vitweb-rejects with the stage and the reason, so the shape of this repo can be argued with rather than taken on trust.

What is in it

source	documents	parts	input files	size	pinned at
web	851,994	148	3	203.5 MB	web-20260819, web-20260820, web-20260820b, web-20260820c, web-20260820d, web-20260821x
total	851,994	148		203.5 MB

Every count here is the row count in a part's own Parquet footer, added up. None of it is what a run reported writing, because a run that died between pushing a part and writing down that it had is exactly the case a count has to be right about.

The per part version of this table is parts.csv at the root of the repo, which is one row per file with its source, its snapshot, the input file it came from, its document count and its size. It is a CSV so that it can be read without a Parquet reader, and it is small enough to open in anything.

Note that web is here at more than one revision. Both revisions are in the repo and every document in them is counted twice above. Filter to one revision by its file name prefix until the old parts are swept.

The repo grows while ingests run, so these numbers are the ones from the last time gao store index was run against it rather than a sealed total. The counts in parts.csv and the counts here always agree, because they are generated together.

Where the text came from

Four public corpora, pinned at a revision, read once, and written out under the schema below. Nothing here was crawled by us. Every one of them has its own card, its own paper in most cases, and its own terms, and the links are the place to read them.

web

851,994 documents.

Two more are pinned in the ingest manifest and are not here. CulturaX is gated on the Hub and the terms were never granted to anybody on this project, so not one byte of it has been read and it is dropped rather than pending. It is mC4 and OSCAR, both built out of Common Crawl, so it went over the same pages the sources above went over, though that is worth less than it sounds: identity here is a hash of the extracted text, and two Common Crawl derivatives in this repo share under one percent of the smaller of them, because two extractors rarely agree on every byte of a page. MADLAD-400 ships as gzipped JSONL rather than Parquet, so it costs a rewrite that the Parquet sources do not, and it is queued behind them.

The manifest with every pinned revision, every input file and its byte count is at https://github.com/tamnd/gao/blob/main/harvest/manifest.json.

How it is laid out

README.md
parts.csv
data/web/
  web-20260819-00000-00000.parquet
  ... and 147 more

One directory per source, and the file name is the snapshot, the input file of the source the part came out of, and the part. The snapshot is the source and the revision it was pinned at, so re-pinning a source puts its new parts beside the old ones in the same directory under a different name rather than moving the directory. That is deliberate: the directory is the config name somebody writes in a load_dataset call, and a name that moves every time a source is re-pinned is a name nobody can write down.

The directories are named plainly rather than Hive style. A Hive path spells the directory snapshot=web-20260819, and then every reader who globs the repo gets a snapshot column in their result set that is in no file, sitting next to a source column that is, so the first thing the layout teaches them is a distinction they did not ask for.

Reading it

The files are Parquet and they are readable in place. Nothing below downloads the repo, and none of it needs a token, because the repo is public.

DuckDB

Install DuckDB, then:

INSTALL httpfs;
LOAD httpfs;

What is in the repo, without opening a single Parquet file. parts.csv is a CSV of one row per part, so this is a few tens of kilobytes of reading.

SELECT source, count(*) AS parts, sum(documents) AS documents,
       round(sum(bytes) / 1e9, 1) AS gb
FROM 'hf://datasets/open-index/vitweb/parts.csv'
GROUP BY source ORDER BY documents DESC;

┌─────────┬───────┬───────────┬────────┐
│ source  │ parts │ documents │   gb   │
│ varchar │ int64 │  int128   │ double │
├─────────┼───────┼───────────┼────────┤
│ web     │   148 │    851994 │    0.2 │
└─────────┴───────┴───────────┴────────┘

Count one source. A count reads the row counts out of each file's footer rather than the file, so this is a few hundred kilobytes whatever the source weighs.

SELECT count(*) AS documents
FROM read_parquet('hf://datasets/open-index/vitweb/data/web/*.parquet');

┌───────────┐
│ documents │
│   int64   │
├───────────┤
│    851994 │
└───────────┘

Group by a column. Parquet is columnar, so a query over two columns reads two columns. This one touches 851,994 documents across 148 files.

SELECT license_class, count(*) AS documents,
       round(avg(n_syllables)) AS mean_syllables
FROM read_parquet('hf://datasets/open-index/vitweb/data/web/*.parquet')
GROUP BY license_class ORDER BY documents DESC;

Look at some documents. Reading text is the one thing here that is not cheap: the row groups hold 50,000 documents each, so the smallest useful read of the text column is a row group of it, which on a full sized part is a couple of hundred megabytes. That is why this one is pointed at a single part, and at the smallest part in the repo, rather than at a glob.

SELECT url, lang, n_syllables, substr(text, 1, 60) AS opening
FROM read_parquet('hf://datasets/open-index/vitweb/data/web/web-20260820c-00001-00019.parquet')
WHERE lang = 'vie' AND n_syllables BETWEEN 200 AND 400
LIMIT 5;

The lang column is ISO 639-3, so the value to filter on is vie rather than the vi in this card's front matter.

Every column and its type.

DESCRIBE SELECT * FROM read_parquet('hf://datasets/open-index/vitweb/data/web/web-20260820c-00001-00019.parquet');

Python

The configs in this card's front matter are what datasets reads, so a source is a config name and default is all of them.

from datasets import load_dataset

# One source, streamed rather than downloaded.
ds = load_dataset("open-index/vitweb", "web", split="train", streaming=True)
print(next(iter(ds))["url"])

Streaming is the right default here. The whole repo does not fit on most disks and one source of it does not fit on many, so a run that reads once should read over the network rather than land the corpus first.

When it does need to be on disk, take a source or a single part rather than the repo.

from huggingface_hub import snapshot_download

# One source on disk, which for the smallest of these is 203.5 MB.
snapshot_download(
    "open-index/vitweb",
    repo_type="dataset",
    allow_patterns="data/web/*",
)

import pyarrow.parquet as pq
from huggingface_hub import hf_hub_download

# One part, for looking rather than training. Read the columns you want:
# text is most of the bytes and a row group of it is a couple of hundred MB.
path = hf_hub_download("open-index/vitweb", "data/web/web-20260820c-00001-00019.parquet", repo_type="dataset")
table = pq.read_table(path, columns=["url", "host", "lang", "n_syllables"])
print(table.num_rows, table.schema.names)

What you can build with it

The repo is Vietnamese pages, three ways, with the measurements that decided each one was worth keeping. All of it is column scans, and the three text columns are large, so name the column you want rather than selecting everything.

Read this before the first query

Not every part in this repo has text in it. The crawl published addresses and measurements and no page text for the first stretch of its life, and the parts written since carry text, markdown and body. The older parts do not have those three columns at all rather than having them empty, so a glob across the whole repo is reading two shapes of file, and DuckDB will stop you rather than quietly hand you nulls:

Invalid Input Error: schema mismatch in glob: column "text" was read from the
original file "...", but could not be found in file "..."

That error is the correct behavior and the fix is union_by_name, which lines the files up by column name and fills the missing ones with nulls. Start here, because it tells you what you actually have:

SELECT schema_version, license_class, count(*) AS rows, count(text) AS with_text
FROM read_parquet('hf://datasets/open-index/vitweb/data/*/*.parquet', union_by_name = true)
GROUP BY ALL ORDER BY schema_version;

There is no sample output under that one, on purpose. It is the query whose answer is the state of the repo on the day you run it, the split moves every time the crawl publishes, and a number printed here would be stale before you read it. Run it and believe the result rather than this page.

schema_version is the filter, and it is a column rather than a filename convention for exactly this reason. A version 1 row is a page recorded before the text columns existed, under the earlier posture that published the address and withheld the page, which is why it still reads restricted. A version 2 row carries the page and reads crawled. Every other column means the same thing in both, so a query about hosts or robots decisions or measurements should read the whole repo, and a query that wants text should carry union_by_name = true and say WHERE schema_version >= 2.

None of this is being backfilled. A version 1 row cannot be upgraded without fetching the page again, since the text was never stored, and rewriting the class on a row whose page we do not have would be a claim about material we are not holding. Those rows stay as they are and the crawl moves forward.

The text queries below all carry the flag and the filter, so they run against the repo as it stands.

One thing about the output boxes below: every one of them is real output, and they do not all come from the same place. A query that reads text can only report on the parts that carry text, so those boxes are from a small run, 680 fetches off twelve Vietnamese news seeds keeping 148 pages, and they are labeled where it matters. A query that does not need text reads the whole repo and its box is the repo's own numbers. The point of printing measured output either way is not that 148 pages describe the corpus, it is that a reader who runs the query gets output shaped like the output shown, which is the thing an invented table cannot promise.

Pretraining text

The plain reading. Every row passed the language test, the length test and the repetition test, so the filter here is about what you want rather than about what is usable.

SELECT text
FROM read_parquet('hf://datasets/open-index/vitweb/data/*/*.parquet', union_by_name = true)
WHERE schema_version >= 2
  AND n_syllables >= 400 AND lang_score >= 0.9 AND diacritics = 'present';

diacritics is worth a thought rather than a default. Vietnamese written without tone marks is still Vietnamese and there is a good deal of it on forums and in comments, so present is the clean slice and dropping the filter is the realistic one.

The same pages with their structure

markdown is the article with its headings, lists, tables and links, which is what a retrieval corpus, a document understanding set or an instruction mining run needs and what plain text has already thrown away.

SELECT count(*) AS pages,
       count(*) FILTER (markdown LIKE '%](%')  AS with_links,
       count(*) FILTER (markdown LIKE '%## %')  AS with_headings,
       count(*) FILTER (markdown LIKE '%|%|%')  AS with_tables
FROM read_parquet('hf://datasets/open-index/vitweb/data/*/*.parquet', union_by_name = true)
WHERE schema_version >= 2;

┌───────┬────────────┬───────────────┬─────────────┐
│ pages │ with_links │ with_headings │ with_tables │
│ int64 │   int64    │     int64     │    int64    │
├───────┼────────────┼───────────────┼─────────────┤
│   148 │        145 │           110 │           4 │
└───────┴────────────┴───────────────┴─────────────┘

Links are on nearly every page and tables are on almost none, which is what Vietnamese news is. Links are rewritten to absolute URLs against the page they were found on, so a link in markdown is a link you can follow rather than a fragment that only meant something inside the original document.

How much of a page the extractor threw away

The three columns side by side are the extraction, measured. body is the whole page, text is what the extractor decided was the article, and the ratio between them is how aggressive it was on that host.

SELECT host, count(*) AS pages,
       round(avg(length(text)))     AS text_chars,
       round(avg(length(markdown))) AS markdown_chars,
       round(avg(length(body)))     AS body_chars
FROM read_parquet('hf://datasets/open-index/vitweb/data/*/*.parquet', union_by_name = true)
WHERE schema_version >= 2
GROUP BY host ORDER BY pages DESC LIMIT 6;

┌───────────────┬───────┬────────────┬────────────────┬────────────┐
│     host      │ pages │ text_chars │ markdown_chars │ body_chars │
│    varchar    │ int64 │   double   │     double     │   double   │
├───────────────┼───────┼────────────┼────────────────┼────────────┤
│ vtv.vn        │    18 │     2744.0 │         5703.0 │    14250.0 │
│ vietnamnet.vn │    16 │     4686.0 │         7253.0 │    24240.0 │
│ tuoitre.vn    │    16 │     4221.0 │         8894.0 │    28953.0 │
│ websosanh.vn  │    13 │     8899.0 │        16854.0 │    24976.0 │
│ nhandan.vn    │    12 │     4713.0 │         9088.0 │    30278.0 │
│ vnexpress.net │     8 │     6442.0 │         7336.0 │    10012.0 │
└───────────────┴───────┴────────────┴────────────────┴────────────┘

A page runs from under twice its article to nearly seven times it, and the difference is the boilerplate the text column is for. How much of it there is turns out to be a fact about the site rather than about the crawl: tuoitre.vn carries about seven times, vnexpress.net about one and a half.

The number to watch is a host whose text_chars is near zero while its body_chars is normal, because that is an extraction failure on that host rather than a site that writes short. It is the query we did not run for a long time, and one large news site was returning two byte articles the whole while.

markdown runs longer than text on every host here, since the link targets and the table pipes are characters too. It is not a different article, it is the same one with its shape left in.

Which Vietnamese sites are worth crawling

A host's yield is the thing every crawler wants and nobody publishes: of the pages we asked a site for, how many turned out to be worth keeping. This repo has the numerator and the rejects repo has the denominator, and the two together are the whole outcome of every request.

No schema_version filter on this one, and that matters. The query counts hosts rather than reading text, so both sides should span the whole crawl. Filtering the kept side to the parts that carry text while leaving the rejects side whole would divide a slice of the numerator by all of the denominator, and every rate would come out far too low.

WITH kept AS (SELECT host, count(*) n FROM read_parquet('hf://datasets/open-index/vitweb/data/*/*.parquet')
              GROUP BY 1),
     rej  AS (SELECT host, count(*) n FROM read_parquet('hf://datasets/open-index/vitweb-rejects/data/*/*.parquet') GROUP BY 1)
SELECT coalesce(kept.host, rej.host) AS host,
       coalesce(kept.n, 0) AS kept, coalesce(rej.n, 0) AS rejected,
       round(coalesce(kept.n, 0) * 100.0 /
             (coalesce(kept.n, 0) + coalesce(rej.n, 0)), 1) AS keep_pct
FROM kept FULL JOIN rej ON kept.host = rej.host
ORDER BY kept DESC LIMIT 8;

┌──────────────────┬───────┬──────────┬──────────┐
│       host       │ kept  │ rejected │ keep_pct │
│     varchar      │ int64 │  int64   │  double  │
├──────────────────┼───────┼──────────┼──────────┤
│ tuoitre.vn       │   552 │      219 │     71.6 │
│ cafef.vn         │   448 │      168 │     72.7 │
│ kenh14.vn        │   446 │      148 │     75.1 │
│ thuockichduc.org │   377 │       89 │     80.9 │
│ poliva.vn        │   357 │       99 │     78.3 │
│ baoquangninh.vn  │   352 │      350 │     50.1 │
│ baotiepthi.com   │   350 │      122 │     74.2 │
│ ruoutot.net      │   344 │       75 │     82.1 │
└──────────────────┴───────┴──────────┴──────────┘

That output is from this repo rather than from a sample run, because this is a query about hosts and the whole crawl is in it.

The spread is the useful part and it is not guessable from outside. ruoutot.net returns four pages in five and baoquangninh.vn returns one in two, which is a real difference in what a crawler should spend on each of them. It also says something about the corpus that the top of this list is drink retailers and celebrity news sitting alongside tuoitre.vn: a high keep rate means a site publishes long Vietnamese prose reliably, not that the prose is worth reading. Nothing here is quality filtered, and this query is a good way to see that.

A FULL JOIN rather than an inner one because the interesting hosts are the lopsided ones: a site that is all rejections never appears in this repo at all, and a site that is all keeps has nothing on the other side.

Watching the crawl move

fetched_at is on every row in both schemas, so this one needs no flag and no filter and reads the whole repo including the parts that predate the text columns.

SELECT date_trunc('day', fetched_at) AS day, count(*) AS kept
FROM read_parquet('hf://datasets/open-index/vitweb/data/*/*.parquet')
GROUP BY day ORDER BY day;

url_template is the other axis worth grouping on. It is the URL with its variable parts replaced, which is what the crawl budgets against, and grouping by it rather than by host is how a calendar trap or a faceted catalog shows up as one template with thousands of rows.

One row

A page this crawler fetched, as SELECT * ... LIMIT 1 returns it. The byte columns are printed as hex here and come back as blobs, and the three text columns are cut, because the point of printing a row is the shape and the article is twenty four hundred characters.

{
  "doc_id": "74a5c75cbd86e2d63cd0f659fa55d5d62cf27313e47a6e118892e7f161a661e4",
  "raw_id": "a7be05565d54907274bc3dd6356d6acb6d90d23d48630dc10eec11e3b61f68e7",
  "text": "Áp thấp nhiệt đới gây mưa lớn cho miền Bắc và Bắc Trung Bộ\n\nÁp thấp nhiệt đới trên vịnh Bắc Bộ có thể gây mưa trên 300 mm từ nay đến đêm 22/8 ở Đông Bắc Bộ và Thanh Hóa ...",
  "markdown": "# Áp thấp nhiệt đới gây mưa lớn cho miền Bắc và Bắc Trung Bộ\n\nÁp thấp nhiệt đới trên vịnh Bắc Bộ có thể gây mưa trên 300 mm từ nay đến đêm 22/8 ở Đông Bắc Bộ và Thanh Hóa ...",
  "body": "Áp thấp nhiệt đới gây mưa lớn cho miền Bắc và Bắc Trung Bộ - Báo VnExpress\n\n[![VnExpress](https://s1.vnecdn.net/vnexpress/restruct/i/v9903/v2_2019/pc/graphics/logo_tagline.svg)](https://vnexpress.net/) [Thứ sáu, 21/8/2026] ...",
  "schema_version": 2,
  "source": "gao-crawl",
  "source_locator": "warc/web-20260821-00000-00000.warc.gz@3983574+56654",
  "url": "https://vnexpress.net/ap-thap-nhiet-doi-gay-mua-lon-cho-mien-bac-va-bac-trung-bo-5111566.html",
  "host": "vnexpress.net",
  "url_template": "vnexpress.net/ap-thap-nhiet-doi-gay-mua-lon-cho-mien-bac-va-bac-trung-bo-5111566.html",
  "fetched_at": "2026-08-21 12:45:18.293+07",
  "media_type": "text/html",
  "extractor": "gao-crawl@1.0.0",
  "pipeline_version": "0.7.0",
  "http_status": 200,
  "robots_decision": "allow",
  "robots_rule": "Allow: /",
  "robots_hash": "0000000000000000000000000000000000000000000000000000000000000000",
  "tdm_signals": {},
  "consent": "open",
  "lang": "vie",
  "lang_score": 0.947,
  "diacritics": "present",
  "translated": false,
  "gao_qual": 0.0,
  "gao_edu": 0.0,
  "hplt_bucket": 0,
  "register": "",
  "heuristics": {"alpha_rate": 0.931, "bare_rate": 0.947, "bullet_rate": 0.0, "diacritic_rate": 0.827, "dup_line_rate": 0.0, "dup_line_runes": 0.0, "ellipsis_rate": 0.0, "mark_rate": 0.827, "mean_syllable": 3.245, "repeat_gram_max": 0.119, "stop_words": 17.0, "syllable_rate": 0.947, "syllables": 510.0, "symbol_rate": 0.0, "top_gram_max": 0.051},
  "dup_cluster": null,
  "dup_cluster_size": 0,
  "is_representative": false,
  "pii_level": 0,
  "pii_types": [],
  "pii_spans": [],
  "license_class": "crawled",
  "license_evidence": "publicly reachable, allowed by robots.txt, and carrying no text and data mining reservation, so it is published as fetched with its address and a takedown path attached, which is the posture Common Crawl publishes under and the one every corpus derived from it inherits",
  "structure": "",
  "n_chars": 2401,
  "n_syllables": 515,
  "n_tokens": 0,
  "contam_flags": [],
  "upstream_fields": {}
}

The three text columns are the same page read three ways and they are worth comparing on this row. text is 2,401 characters, markdown is 2,666 of the same article with the headline promoted to # and the links kept, and body is 5,395, which is the article plus the masthead, the navigation and the footer. That ratio is what the extractor removed.

consent is open, which means the page was asked and reserved nothing. It is not the same as empty, which means nobody was there to ask. robots_decision and robots_rule say which line of which robots.txt allowed the fetch at the time it happened rather than now, and source_locator is the WARC volume, offset and length on the box that fetched it, which is how the page can be extracted again by a later extractor without asking the site a second time.

repeat_gram_max and top_gram_max in heuristics are the repetition measurements this page was judged on, and they are on every row including the rejected ones, so the threshold that keeps or drops a page is a number anybody can move.

gao_qual, gao_edu, n_tokens and pii_level are zero because the stages that fill them have not run on this repo. They are in the schema so that a query written here still runs against a release, where they are filled.

The columns

44 columns, in file order. This is the schema as it stands, and within one schema version a column a stage has not run yet is null rather than absent, so a query written against one source works against the next.

Across versions that does not hold. Columns are added over time, and a part written before a column existed does not have it at all rather than having it empty, which is why schema_version is a column and why a query spanning the whole repo may need union_by_name = true. Grouping by schema_version is the way to see which shapes are actually in front of you.

column	type	filled in by	meaning
doc_id	bytes(32)	normalize	blake3 of the normalized text, which is the document's identity: two documents with the same normalized text are the same document whichever path found them
raw_id	bytes(32)	harvest	blake3 of the bytes before extraction, which is what links this row back to the WARC record or the source file it came out of
text	string	normalize	the document text, normalized to NFC with canonical tone mark placement and legacy encodings already transcoded
markdown	string	normalize	the same content as text with the document's shape left in, as CommonMark: headings, lists, tables, links and emphasis, normalized the same way except for the whitespace, which in markdown is the markup
body	string	normalize	the whole page as markdown, with only the elements that are not writing at all taken out, which is what a reader who disagrees with our extraction can run their own over, and what made an extractor bug recoverable without refetching the web
schema_version	uint16	store	the version of this layout, carried per row because a store appended to across a pipeline upgrade holds two versions at once and a reader has to be able to tell
source	string	harvest	which acquisition path produced the document, one of the six gao runs
source_locator	string	harvest	where in that source it came from: shard and offset for an ingested corpus, file, offset and length for a WARC record
url	string	harvest	the page it came from, canonicalized
host	string	harvest	the host of that URL, which is the unit politeness, budgets and takedowns are all measured in
url_template	string	harvest	the URL with its variable path and query parts replaced by placeholders, which is what the crawl budgets against and how a calendar trap reads as one URL rather than ten thousand
fetched_at	timestamp(millisecond)	harvest	when the document was fetched, in UTC milliseconds
media_type	string	harvest	the media type the response declared, before extraction decided what to do with it
extractor	string	harvest	name and semver of the extractor, because two documents extracted by different versions of the same extractor are not comparable
pipeline_version	string	store	semver of the cleaning pipeline that produced this row
http_status	uint16	harvest	the status the fetch got, empty for a document that arrived through somebody else's corpus rather than through our crawl
robots_decision	string	harvest	what robots.txt said about this fetch, recorded per fetch rather than assumed from a global setting so that a consent question years later has an answer
robots_rule	string	harvest	the rule that decided it, in the spelling the site wrote
robots_hash	bytes(32)	harvest	blake3 of the robots.txt the decision was made against, so the decision can be rechecked against the file rather than against the file as it is today
tdm_signals	map<string, string>	harvest	the machine readable text and data mining reservations the response carried, keyed by mechanism and holding what that mechanism said
consent	string	harvest	what the page said about being kept and trained on, in one word, where empty means nobody asked rather than the page said yes
lang	string	sift	the language identifier's verdict, which is vie for everything in gao and is stored anyway because a column that is constant today needs no migration tomorrow
lang_score	float32	sift	how sure the identifier was
diacritics	string	sift	present, absent or mixed, because Vietnamese written without tone marks is still Vietnamese and is still not the same distribution
translated	bool	sift	the machine translation detector's verdict, since translated Vietnamese reads as fluent to a metric and as wrong to a native speaker
gao_qual	float32	sift	the quality classifier's score for this document
gao_edu	float32	sift	the educational value score, which is what the gao-edu slice is selected on
hplt_bucket	uint8	harvest	the source corpus's own quality bucket where it had one, kept so gao's classifier can be compared against an independent one rather than only against itself
register	string	harvest	the source corpus's own register label, kept for the same reason
heuristics	map<string, float32>	sift	the raw heuristic measurements rather than the verdicts, so the corpus can be refiltered at a different threshold without being recomputed from the text
dup_cluster	bytes(16)	mill	which duplicate cluster the document belongs to, empty when it is in none
dup_cluster_size	uint32	mill	how large that cluster is
is_representative	bool	mill	marks the one document per cluster a deduplicated view keeps, with the rest left in the store because deduplication is tuned rather than maximized
pii_level	uint8	cover	how much personal data has been removed: none, the structured identifiers, or those plus addresses and identifying names
pii_types	list<string>	cover	which kinds of personal data were found
pii_spans	list<span>	cover	where they were found, empty on every row the cleaning line writes, because the offsets index the text before it was covered and because offsets published next to covered text say where the identifiers were
license_class	string	law	the per document redistribution determination, stored by name so a file read without gao says restricted rather than 3
license_evidence	string	law	what determined that class, since a class without evidence is a guess
structure	string	harvest	what the document is: article, forum thread, legal, thesis, gazette, transcript, which drives both the extraction handler and the mixture weights
n_chars	uint32	normalize	how many characters the text holds
n_syllables	uint32	normalize	how many Vietnamese syllables it holds, which is the unit that survives a change of tokenizer
n_tokens	uint32	count	how many gao tokens it holds, under the tokenizer named in the manifest
contam_flags	list<string>	pick	which evaluation benchmarks this document overlaps, flagged rather than deleted so one store can serve a training run that excludes them and an analysis that counts them
upstream_fields	map<string, string>	harvest	the source corpus's own metadata, verbatim, which is the difference between answering a provenance question later and having to ingest again

pii_spans is a list of structs, and the struct is:

field	type	meaning
start	uint32	byte offset into the text where the identifier begins
len	uint32	how many bytes long it is, counted in bytes rather than runes because a reader slicing the text has bytes
type	string	which kind of identifier it is, from the same set pii_types draws on

The full schema, including the Parquet spelling of each type and what the dictionary encoded columns cost, is at https://github.com/tamnd/gao/blob/main/SCHEMA.md.

What this repo is

What a stage wrote on its way to a release, published as it is written so that a box can push a part and delete it rather than holding what it has finished. It is public like everything else here, it is rewritten when a source is pinned again, and it is not covered by a signed manifest. A release is, and that is the difference worth knowing before anybody builds on this.

What ships and what does not

This repo carries document text, so it carries only documents whose text may be redistributed.

license class	text	metadata
crawled	yes	yes

Every row carries its own class in the license_class column, so a reader who needs a narrower set than this repo holds can filter for it rather than trust the repo name.

Why a crawled page ships its text

No license was granted for these pages and none is claimed. What crawled records is a publication posture, and it is the one Common Crawl fetches and publishes under, which is the same posture fineweb-2, HPLT, GlotCC and MADLAD-400 inherit by being built from Common Crawl's archives. A page is here because it was publicly reachable without a login, robots.txt allowed the fetch, and the page carried no machine readable text and data mining reservation. It is published as it was fetched, with the address it was fetched from on the row.

Copyright in each page stays with whoever wrote it. Nothing here transfers it and nothing here grants it onward. Anybody using this dataset is making their own determination about their own use under their own law, exactly as they would be with any corpus built from a web crawl, and the columns to make that determination with are on every row: url, host, fetched_at, robots_decision, robots_rule, consent and license_evidence.

If you own a page in here and want it out, open an issue at https://github.com/tamnd/gao/issues. Say the host, and the paths if it is not the whole host, and say which of two things you want. stop means stop crawling it, and takes effect at the fetch and at every write into the store from then on. erase means that and rebuilding the published parts without it. The two are asked apart because they cost different things and guessing gets it wrong in both directions.

Every request is written into GO-BO.toml at the root of https://github.com/tamnd/gao, with when it was filed and when it was actually honored, and gao takedown status prints the worst case rather than the median, because a median hides the request that broke the promise. The response time we hold ourselves to is 72 hours and it is in LIEN-HE.md next to the register. A register with nothing in it reports that nothing has been measured rather than a clean record, since a takedown path nobody has used is a path nobody has tested.

A page that reserved its text and data mining rights is not here, whatever its license says. The two are separate questions and the reservation is honored at the write, so a page that said no cannot reach a published file through a stage that forgot to ask. The consent column records what each page said, and an empty value means nobody was there to ask, which is true of every document that came out of somebody else's corpus.

Things to know before you use it

The three text columns are not three copies of the same thing. text is the extractor's article as plain prose, markdown is that article with its structure, and body is the whole page before the extractor chose. body includes the navigation, the footer, the related links and the cookie notice, so it is the wrong column to train on and the right one to re-extract from. A run that reads body and means text will produce a model that writes menus.

The extraction is a heuristic and it has been wrong at scale. It reads the page's containers, discards the ones named for furniture, and measures the ones named for position before deciding, because a container called sidebar sometimes holds the article. That rule exists because the previous one did not have it and every article on one large Vietnamese news site came back as two bytes for the life of a crawl. n_chars is on every row, so a host whose pages all came back short is a GROUP BY host away and worth checking before trusting that host's rows.

Nothing here is deduplicated. Not within a run and not across them. Vietnamese news is syndicated heavily, so the same wire story is here under several hosts with different boilerplate around it, and doc_id is a hash of the normalized text, which means those copies are only equal if the extraction agreed byte for byte. It usually does not. Deduplicate before you train, and expect near duplicate detection to find a good deal more than exact matching does.

Personal information has not been removed. pii_level is 0 and pii_types and pii_spans are empty on every row, because the stage that fills them has not run on this repo. That is not a finding that the pages are clean, it is the absence of a measurement. Vietnamese news carries bylines, quoted names, phone numbers in classified sections and email addresses in author blocks, and all of it is in text, markdown and body exactly as it was on the page. Filter before you train rather than after.

Not every part has text. The parts written before the text columns existed do not carry text, markdown or body at all, and they read schema_version = 1 and license_class = 'restricted' because they were published under the earlier posture that gave out the address and withheld the page. A query that names a text column across the whole repo needs union_by_name = true or DuckDB will stop it, and WHERE schema_version >= 2 is the filter that means the pages. None of it is being backfilled, since the text of those pages was never stored and refetching them is a crawl rather than an edit.

robots.txt is honored and so is tdmrep.json. A page under a Disallow is not fetched, and a page whose site reserved its text mining rights is fetched, measured and then rejected rather than kept. Both of those are rows in open-index/vitweb-rejects with the rule on them. It means the corpus is smaller than the web and that the difference is auditable.

The measurements are gao's own and they are not a quality judgment. lang_score is the share of tokens that are Vietnamese syllables, heuristics is the full map the sift produced, and gao_qual and gao_edu are zero because the classifier behind them is trained against a reference set that does not exist yet. A page is here because it is Vietnamese prose of some length, not because it is good.

The repetition filter removes party and government prose, and that is a known fault rather than a finding about the writing. On the first run a third of the repetition rejections were article pages rather than listing pages. Two of them were pulled out and read: the extraction was clean, with no navigation and no related stories in it, and what pushed them over the threshold was the register. An official is named in full every time they are mentioned, so đồng chí Vũ Quyết Tiến, Phó Bí thư Tỉnh ủy, Chủ tịch Ủy ban MTTQ tỉnh is three occurrences of the same eight syllable gram in a nine hundred word article, and the body doing the meeting is named in full in every paragraph about it. The threshold those pages fail is Gopher's, scaled from words to syllables, and a Vietnamese title is long in syllables and carries one fact. Every page it removed is in open-index/vitweb-rejects with its measured rate, so the threshold can be moved and the corpus recomposed without fetching anything again.

It is a crawl in progress and the parts are the order it happened in. Nothing is shuffled and nothing is deduplicated across runs. Consecutive rows are frequently from one host, because a crawl of a host is a run of requests to that host, so the first N rows are a sample of one site rather than of the corpus.

A crawl is not a snapshot of the web. It is a snapshot of what a seed list plus link following reached, under a budget that closes a template once it stops producing new text. Sites nobody linked to and nobody seeded are absent, and absence here is not evidence of anything.

What this is not

This is not a release. There is no signed manifest behind it, no merkle root over the files, and no promise that a part will still be there next week under the same name. A run pushes each part as it closes it and deletes the local copy, which is what lets a box with a terabyte of disk work through corpora that do not fit on it, and it means the file list is whatever the last run got through rather than a set anybody has fixed.

What that changes for a reader:

• Read it to see what the pipeline produces, and to build on the raw text under one schema without pulling four corpora in four formats.
• Do not cite a document count off it in anything that has to still be true later. Cite a release.
• Re-pinning a source rewrites its parts under a new revision in the same directory, so a query that has to be stable should name a revision rather than a source.
• Nothing here has been deduplicated against anything else here. The same page can be in three of these corpora and it is three documents in this repo.

The releases carry the signed manifest, the dedup, and the quality filtering. They are the other repos in open-index.

Citation

If you use this, cite the corpora it is made of. They did the collecting. This repo did the reading.

For the assembly itself:

@misc{vitweb,
  title        = {ViTweb: Vietnamese corpora under one schema},
  author       = {The gao project},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/datasets/open-index/vitweb}},
  note         = {Built with gao, https://github.com/tamnd/gao}
}

Where this comes from

The pipeline that built it, the ingest contract every document had to pass, and the reasoning behind both are at https://github.com/tamnd/gao.

This card is generated by gao store card, from the snapshot manifest where there is one and from parts.csv where there is not. Editing it by hand works until the next run overwrites it.