Best Synthetic Data Generation Tools in 2026: Faker, SDV, MOSTLY AI and NVIDIA NeMo Compared

Type gretel.ai into your browser today and you land on nvidia.com. NVIDIA bought Gretel in March 2025, reportedly for more than its $320 million valuation, folded the roughly 80-person team in, and the product resurfaced as NeMo Data Designer under Apache 2.0. That redirect is a decent summary of what happened to this category in the last eighteen months: the independent vendors got acquired or repriced, and the open-source options got genuinely good.

The other thing that happened is quieter and matters more if you are picking a library this week. The Synthetic Data Vault, the most-cited open-source option in the space, is no longer MIT licensed. It moved to the Business Source License.

Every license and price below came from the vendor's own page or repository in August 2026, and every number in the comparison test at the end was produced on a laptop with the versions named.

The Three Jobs People Call "Synthetic Data"

The phrase covers three genuinely different jobs, and most bad tool choices come from buying for one and needing another.

Mock data invents plausible-looking rows from nothing: names, emails, addresses. It has no relationship to your real data because it has never seen it. This is what you want for seeding a dev database or writing a test fixture.

Statistical synthesis trains a model on your real table and generates new rows that hold the same distributions and, critically, the same relationships between columns. This is what you want when something downstream will learn from the data, or when a query needs to return realistic aggregates.

De-identification starts from production data and transforms it so individuals cannot be re-identified, keeping row-level structure intact. This is what compliance teams usually mean, and it is a different engineering problem from the first two.

The gap between the first and second is the single most expensive misunderstanding here, so the test at the end of this post measures exactly that.

Quick Comparison

The Open Source Options

Faker: The Default, and It Is Not a Synthesizer

Use it for fixtures and seed data, never for anything a model will learn from. Faker is MIT licensed, ubiquitous, and has ports in most languages, including @faker-js/faker for JavaScript. Version 40.36.0 is current on PyPI.

The feature that makes it genuinely useful in CI is the seed. Seed it and the output is byte-identical between runs, which turns generated data into a fixture you can assert against:

Python
Copy
from faker import Faker

fake = Faker("en_US")
Faker.seed(42)

for _ in range(3):
    print(f"{fake.name()},{fake.email()},{fake.city()},{fake.state_abbr()},{fake.zipcode()}")

Run locally with Faker 40.36.0, that prints the same rows every time:

text
Copy
Allison Hill,donaldgarcia@example.net,New Roberttown,CO,29158
Lance Hoffman,lrobinson@example.com,Port Lindachester,MA,36922
Tyler Rogers,jamesmichael@example.com,Lindsaymouth,ND,16862

Two runs of that exact script produce an identical MD5, c14118a513b07366c421e7c09d0e51db. One caveat that bites people: the seed fixes the whole random stream, not each field independently, so adding or removing a single fake.* call shifts every value after it. Pin the script, not just the seed.

What Faker cannot do is preserve any relationship between columns, because it generates each one independently. That is not a bug, it is the design, and it is why the section after the tools matters.

SDV: Excellent, and No Longer MIT

Still the most capable open synthesizer, but read the license before you ship it. SDV started at MIT's Data to AI Lab in 2016 and is maintained by DataCebo. It handles single tables, multi-table relational data with foreign keys, and sequential data, and it ships quality-evaluation and visualization utilities that most alternatives lack. Version 1.38.0 is current, at about 3,500 GitHub stars.

The change worth knowing: SDV is now under the Business Source License, not MIT. That is the same license family Terraform and Vault moved to, and it is the same practical question those moves raised, which our infrastructure as code comparison and secrets management guide both ran into. BUSL permits a lot of use but is not an OSI-approved open-source license, and the terms matter if synthetic data generation is part of what you sell. Read it rather than assuming, because plenty of listicles still call SDV "MIT licensed."

MOSTLY AI SDK: Apache 2.0 and Local by Default

The permissively licensed synthesizer, and it does not phone home. MOSTLY AI open-sourced its Synthetic Data SDK under Apache 2.0, and the documentation is explicit that LOCAL mode is the recommended install: training and generation both happen on your own hardware, with no cloud account required. Install it with mostlyai[local], or mostlyai[local-gpu] if you have one.

It handles mixed-type data across single-table, multi-table, and time-series shapes, and supports probing a trained generator on demand rather than only batch generation. If the BUSL question above rules out SDV for your use case, this is the first alternative to try, and the license is the reason.

NVIDIA NeMo Data Designer: What Gretel Became

Aimed at generating training data for models, not at cloning your production table. Data Designer builds datasets either from scratch or from seed data, combining statistical samplers with LLM calls, and it is Apache 2.0.

The design reflects its purpose: dependency-aware generation so fields can reference each other, validators in Python and SQL, LLM-as-a-judge scoring on the output, and a preview mode so you can check a config before paying to generate at scale. Those last two matter because LLM-generated datasets fail in ways statistical synthesis does not, mostly low diversity and repeated phrasing.

NVIDIA's own page on this cites a Gartner projection that by 2026, 75 percent of businesses will use generative AI to create synthetic customer data, up from less than 5 percent in 2023. Treat vendor-quoted analyst numbers as directional.

The Commercial Platforms

Tonic.ai is the one most teams evaluate, and it splits into three products worth keeping straight. Fabricate generates data from scratch, including through a conversational interface, and is the only piece with public self-serve pricing: a free tier with $5 in monthly credits, and Plus at $29 per month with $25 in credits plus pay-as-you-go beyond that. Structural is the test-data-management product, doing de-identification and subsetting against real databases like Postgres, MySQL, SQL Server, Snowflake, and BigQuery, priced by quote (Professional covers up to 10TB and 10 users; Enterprise removes the caps and adds self-hosting). Textual handles unstructured files, billed per 1,000 words processed.

That split is the useful thing to notice: the cheap, self-serve product is the mock-data one, and the product that touches your actual production database is the quote-based one. That pattern holds across this category. K2view, Syntho, and YData occupy similar enterprise ground, all quote-based, and Hazy was acquired by SAS. If you need a signed DPA and a database connector, you are buying an enterprise contract regardless of vendor.

The Test I Would Run Before Trusting Any of Them

Here is the experiment that separates the three jobs, and it takes about twenty lines. Generate real data with a deliberate relationship, salary tracking years of experience. Then produce two synthetic versions: one with columns generated independently, which is what a mock-data library gives you, and one from an actual synthesizer.

Python
Copy
import random, statistics

random.seed(42)

real = []
for _ in range(500):
    years = random.randint(0, 40)
    real.append((years, 55_000 + years * 3_200 + random.gauss(0, 6_000)))

# Each column plausible on its own, generated independently.
independent = [(random.randint(0, 40), random.uniform(55_000, 190_000)) for _ in range(500)]

def describe(label, pairs):
    xs, ys = zip(*pairs)
    print(f"{label:<22} corr={statistics.correlation(xs, ys):+.3f}  "
          f"mean_salary=${statistics.mean(ys):>9,.0f}  mean_years={statistics.mean(xs):.1f}")

describe("real data", real)
describe("independent columns", independent)

Then the same table through SDV 1.38.0:

Python
Copy
import pandas as pd
from sdv.metadata import Metadata
from sdv.single_table import GaussianCopulaSynthesizer

df = pd.DataFrame(real, columns=["years_experience", "salary"])
metadata = Metadata.detect_from_dataframe(df, table_name="employees")

synth = GaussianCopulaSynthesizer(metadata)
synth.fit(df)
sample = synth.sample(num_rows=500)

The three results, all run locally:

text
Copy
real data              corr=+0.988   mean_salary=$  119,977   mean_years=20.3
independent columns    corr=-0.061   mean_salary=$  123,101   mean_years=20.4
SDV synthetic          corr=+0.880   mean_salary=$  118,319   mean_years=21.5

Look at what matches and what does not. All three have a mean salary within about $5,000 of each other and a mean tenure within about a year. Any eyeball check, any dashboard, any "does this look reasonable" review passes all three. But the correlation between experience and pay goes from +0.988 in the real data to -0.061 with independent columns. The relationship is not weakened, it is gone. A model trained on that data would learn that experience has no bearing on salary.

SDV holds it at +0.880. Not perfect, and that gap is worth knowing about rather than glossing over: statistical synthesis approximates, and the approximation costs you some fidelity in exchange for not shipping real records. Speaking of which, the same run produced zero rows that appear in the original table, which is the property you actually want. A synthesizer that reproduced real rows would be a privacy leak wearing a synthetic-data label.

If you take one thing from this post: run this test on your own table before you trust any tool here, including the paid ones. Matching averages proves nothing.

How to Pick

Seeding a dev database or writing test fixtures: Faker, seeded. Nothing else is needed and nothing else is faster.

Training or evaluating a model on data you cannot use directly: MOSTLY AI SDK if the license needs to be permissive, SDV if you want the deepest feature set and the BUSL terms work for you.

Generating instruction or eval datasets for LLMs: NeMo Data Designer, and use its preview mode and judge scoring rather than trusting bulk output.

Connecting to a real production database with compliance sign-off: a commercial platform, realistically Tonic Structural or a peer, on a quote. Budget for procurement, not a credit card.

Just need believable rows in a hurry with no install: our Fake Data Generator does this in the browser, and the SQL Insert Generator turns the result into statements you can paste straight into a seed script.

Wiring Synthetic Data Into a Project This Week

1. Decide which of the three jobs you have. Write it down in one sentence. Most tool regret traces back to skipping this step.
2. Start with mock data and a fixed seed. Generate the rows you need for local development, commit the seed rather than the data, and confirm two runs produce identical output.
3. Turn the rows into a loadable seed. Our SQL Insert Generator converts generated records into INSERT statements, and the Fake Data Generator covers the generation itself if you would rather not add a dependency.
4. Check the values are actually valid, not just plausible. Generated payment data in particular needs to pass a checksum before your validation layer rejects every row; the Credit Card Validator confirms a test number satisfies the Luhn check.
5. Eyeball the output as a table, not as a string. Load the generated CSV into our CSV Viewer before you trust a few thousand rows you have only seen as terminal output.
6. Run the correlation test above if anything downstream learns from the data. If your key relationships do not survive, you need a synthesizer, not a mock library.
7. Verify no real rows survived into the synthetic output if you trained on production data. An inner join against the source should return nothing.

Conclusion

The consolidation is real: Gretel is NVIDIA's now, Hazy is SAS's, and the enterprise end of this market is quote-based across the board. The good news is that the open end got stronger at the same time. MOSTLY AI's SDK is Apache 2.0 and runs entirely on your hardware, NeMo Data Designer is Apache 2.0, and Faker remains MIT and perfect at the narrow job it does. The one thing to check rather than assume is SDV's license, which is no longer MIT despite what most roundups still say. Then run the correlation test on your own data, because the difference between mock data and synthetic data does not show up in the averages.

Related DevToolLab Tools

• Fake Data Generator - Generate believable names, emails and addresses in the browser, with no library to install.
• SQL Insert Generator - Turn generated records into INSERT statements for a seed script.
• Credit Card Validator - Confirm a generated test card number passes the Luhn check before your validation layer rejects it.
• CSV Viewer - Inspect a generated dataset as a real table instead of scrolling terminal output.

Related Guides

• Best Infrastructure as Code Tools - the same Business Source License question, playing out in Terraform and OpenTofu
• Best Secrets Management Tools - where the credentials in your seed scripts and connection strings belong
• Best AI QA and Autonomous Testing Tools - the testing layer that consumes the data you generate here
• LLM Evals Guide - measuring whether a model trained on synthetic data actually got better

Licenses, prices and product lineups change often. Verify current terms on each vendor's own page before committing to a tool.