CLI Commands Reference

This page should provide additional high-level documentation and explanation beyond just chia -h.

This is not meant to be comprehensive, because often the -h (help) text is clear enough. We recommend fully investigating with the -h switch before looking elsewhere.

If want to know what a command’s options are, append -h at the end to see options and explanations.

Some examples:

  • chia -h
  • chia plots -h
  • chia plots check -h
  • chia start -h

As with the rest of this project, this doc is a work-in-progress. Feel free to browse the source code or the Chia Proof of Space Construction Document for more insight in the meantime.

Locate the chia binary executable


If you installed in your /Applications directory, you can find the chia binary at /Applications/

Do a sanity check in with

/Applications/ -h

You can use that if you augment your PATH with


and then chia -h should work.


There is more than one chia.exe binary; the GUI is Chia.exe (two of these!) and the CLI is chia.exe. They are found in different places. Note the big C versus the little c.

The CLI one is the one referred to in this document, and for version 1.1.3 it can be found at



Command: chia init

First, init checks for old versions of chia installed in your ~/.chia directory.

If so, init migrates these old files to the new version:

  • config (including old SSL files)
  • db
  • wallet
  • Using config.yaml, updates wallet keys and ensures coinbase rewards go to the right wallet puzzlehash.

If no old version exists, init:

  • Creates a default chia configuration
  • Initializes a new SSL key and cert (for secure communication with the GUI)


Command: chia start {service}

  • Service node will start only the full node.
  • Service farmer will start the farmer, harvester, a full node, and the wallet.
  • positional arguments: {all,node,harvester,farmer,farmer-no-wallet,farmer-only,timelord,timelord-only,timelord-launcher-only,wallet,wallet-only,introducer,simulator}


-r, --restart: Restart of running processes



Command: chia plots create [add flags and parameters]


-k [size]: Define the size of the plot(s). For a list of k-sizes and creation times on various systems check out: k-Sizes

-n [number of plots]: The number of plots that will be made, in sequence. Once a plot is finished, it will be moved to the final location -d, before starting the next plot in the sequence.

-b [memory buffer size MiB]: Define memory/RAM usage. Default is 4608 (4.6 GiB). More RAM will marginally increase speed of plot creation. Please bear in mind that this is what is allocated to the plotting algorithm alone. Code, container, libraries etc. will require additional RAM from your system.

-f [farmer pk]: This is your “Farmer Public Key”. Utilise this when you want to create plots on other machines for which you do not want to give full chia account access. To find your Chia Farmer Public Key use the following command: chia keys show

-p [pool pk]: This is your “Pool Public Key”. Utilise this when you want to create plots on other machines for which you do not want to give full chia account access. To find your Chia Pool Public Key use the following command: chia keys show

-a [fingerprint]: This is the key Fingerprint used to select both the Farmer and Pool Public Keys to use. Utilize this when you want to select one key out of several in your keychain. To find your Chia Key Fingerprint use the following command: chia keys show

-t [tmp dir]: Define the temporary directory for plot creation. This is where Plotting Phase 1 (Forward Propagation) and Phase 2 (Backpropagation) both occur. The -t dir requires the largest working space: normally about 4 times the size of the final plot.

-2 [tmp dir 2]: Define a secondary temporary directory for plot creation. This is where Plotting Phase 3 (Compression) and Phase 4 (Checkpoints) occur. Depending on your OS, -2 might default to either -t or -d. Therefore, if either -t or -d are running low on space, it’s recommended to set -2 manually. The -2 dir requires an equal amount of working space as the final size of the plot.

-d [final dir]: Define the final location for plot(s). Of course, -d should have enough free space as the final size of the plot. This directory is automatically added to your ~/.chia/VERSION/config/config.yaml file. You can use chia plots remove -d to remove a final directory from the configuration.

-r [number of threads]: 2 is usually optimal. Multithreading is only in phase 1 currently.

-u [number of buckets]: More buckets require less RAM but more random seeks to disk. With spinning disks you want less buckets and with NVMe more buckets. There is no significant benefit from using smaller buckets – just use 128.

-e [bitfield plotting]: Using the -e flag will disable the bitfield plotting algorithm, and revert back to the older b17 plotting style. After 1.0.4 it’s better to use bitfield for most cases (not using -e). Before 1.0.4 (obsolete) using the -e flag (bitfield disabled) lowers memory requirement, but also writes about 12% more data during creation of the plot. For now, SSD temp space will likely plot faster with -e (bitfield back propagation disabled) and for slower spinning disks, i.e SATA 5400/7200 rpm, not using -e (bitfield enabled) is a better option.

Example Plotting Commands

Example below will create a k32 plot and use 4GB (note – not GiB) of memory.

chia plots create -k 32 -b 4000 -t /path/to/temporary/directory -d /path/to/final/directory

Example 2 below will create a k34 plot and use 8GB of memory, 2 threads and 64 buckets

chia plots create -k 34 -e -b 8000 -r 2 -u 64 -t /path/to/temporary/directory -d /path/to/final/directory

Example 3 below will create five k32 plots (-n 5) one at a time using 4GB -b 4000 (note – not GiB) of memory and uses a secondary temp directory (-2 /path/to/secondary/temp/directory).

chia plots create -k 32 -b 4000 -n 5 -t /path/to/temporary/directory -2 /path/to/secondary/temp/directory -d /path/to/final/directory

Additional Plotting Notes

  • During plotting, Phase 1 (Forward Propagation) and Phase 3 (Compression) tend to take the most time. Therefore, to maximize plotting speed, -t and -2 should be on your fastest drives, and -d can be on a slow drive.
  • There are 4 major phases to plotting. Phase 1 of plotting can utilize multi-threading. Phases 2-3 do not. You can better optimize your plotting by using the -r flag in your command and setting it to greater than 2, e.g,. -r 2. Above 4 threads there are diminishing returns. Many Chia users have determined it’s more efficient to plot in parallel, rather than series. You can do this by just having multiple plotting instances open but staggering when they start 30min or more.
  • It’s objectively faster to plot on SSD’s instead of HDD’s. However, SSD’s have significantly more limited lifespans, and early Chia testing has seemed to indicate that plotting on SSD’s wears them out pretty quickly. Therefore, many Chia users have decided it’s more “green” to plot in parallel on many HDD’s at once.
  • Plotting is designed to be as efficient as possible. However, to prevent grinding attacks, farmers should not be able to create a plot within the average block interval. That’s why the minimum k-size is k32 on mainnet.


Command: chia plots check -n [num checks] -l -g [substring]

First, this looks in all plot directories from your config.yaml. You can check those directories with chia plots show. This command will check whether plots are valid given the plot’s associated keys and your machine’s stored Chia keys, as well as test the plot with challenges to identify found plots vs. expected number of plots.

-g check only plots with directory or file name containing case-sensitive [substring]. If -g isn’t specified all plots in every plot directory in your config.yaml will be checked.

Examples for using -g

  • Check plots within a long directory name like /mnt/chia/DriveA can use chia plots check -g DriveA
  • Check only k33 plots can use chia plots check -g k33
  • Check plots created on October 31, 2020 can use chia plots check -g 2020-10-31

-l allows you to find duplicate plots by ID. It checks all plot directories listed in config.yaml and lists out any plot filenames with the same filename ending; *-[64 char plot ID].plot. You should use -l -n 0 if you only want to check for duplicates.

-n represents the number of challenges given. If you don’t include an -n integer, the default is 30. For instance, if -n is 30, then 30 challenges will be given to each plot. The challenges count from 5 (minimum) to -n, and are not random.

Each plot will take each challenge and:

  • Get the quality for the challenge (Is there a proof of space? You should expect 1 proof per challenge, but there may be 0 or more than 1.)
  • Get the full proof(s) for the challenge if a proof was present
  • Validate that the # of full proofs matches the # of expected quality proofs.

Finally, you’ll see a report the final true proofs vs. expected proofs.

Therefore, if -n is 20, you would expect 20 proofs, but your plot may have more or fewer.

Running the command with -n 10 or -n 20 is good for a very minor check, but won’t actually give you much information about if the plots are actually high-quality or not.

Consider using -n 30 to get a statistically better idea.

For more detail, you can read about the DiskProver commands in chiapos

What does the ratio of full proofs vs expected proofs mean?

  • If the ratio is >1, your plot was relatively lucky for this run of challenges.
  • If the ratio is <1, your plot was relatively unlucky.
    • This shouldn’t really concern you unless your ratio is <0.70 # If so, do a more thorough chia plots check by increasing your -n

The plots check challenge is a static challenge. For example if you run a plots check 20 times, with 30 tries against the same file, it will produce the same result every time. So while you may see a plot ratio << 1 for a plot check with x number of tries, it does not mean that the plot itself is worthless. It just means that given these static challenges, the plot is producing however many proofs. As the number of tries (-n) increases, we would expect the ratio to not be << 1. Since Mainnet is live, and given that the blockchain has new challenges with every signage point – just because a plot is having a bad time with one specific challenge, does not mean it has the same results versus another challenge. “Number of plots” and “k-size” are much more influential factors at winning blocks than “proofs produced per challenge”.

In theory, a plot with a ratio >> 1 would be more likely to win challenges on the blockchain. Likewise, a plot with a ratio << 1 would be less likely to win. However, in practice, this isn’t actually going to be noticeable. Therefore, don’t worry if your plot check ratios are less than 1, unless they’re significantly less than 1 for many -n.

Other commands (not yet documented)

$ chia

  --root-path PATH  Config file root  [default: /home/mariano/.chia/mainnet]
  -h, --help        Show this message and exit.

  configure   Modify configuration
  farm        Manage your farm
  init        Create or migrate the configuration
  keys        Manage your keys
  netspace    Estimate total farmed space on the network
  plots       Manage your plots
  run_daemon  Runs chia daemon
  show        Show node information
  start       Start service groups
  stop        Stop services
  version     Show chia version
  wallet      Manage your wallet

To see what you can do with each of these commands, use the help flag -h. For example, chia show -h.

To check your full node status, do chia show -s and you’ll see something like this. To figure how close you are look at your height. Once fully synced it’ll say Full Node Synced at the top.

Current Blockchain Status: Full Node Synced

Peak: Hash: 34554a10aff6b52545623e18667c9487758fa93a3b2345974da0d263939189dc
      Time: Tue Mar 23 2021 20:54:46 JST                  Height:      19882

Estimated network space: 136.225 PiB
Current difficulty: 9
Current VDF sub_slot_iters: 112197632
Total iterations since the start of the blockchain: 63291534050

  Height: |   Hash:
    19882 | 34554a10aff6b52545623e18667c9487758fa93a3b2345974da0d263939189dc
    19881 | f53c052cd7ac58539ff5c35cb9d515bc521308a49cec7566b23dba84f76009d8
    19880 | 924d825a7fdbfd61e4582efbbe1d977bb554b368eea58c349a71e688e43fcc49

You can add and remove directories for your plots with chia plots add -d 'your_dir' or chia plots remove -d 'your_dir', help can be found for respective add/remove with chia plots add/remove -h

Checking Logs and Status

You can check contents of your wallet with: chia wallet, and status of your farmer with chia farm summary.

Check harvester and farmer logs: grep ~/.chia/mainnet/log/debug.log -e harvester

Sample result:

17:08:03.191 harvester harvester_server        : INFO     <- harvester_handshake from peer 214b269a425b8223cb50fbd458dab056599348e255f07a018c13ea9efb509ee5
17:08:03.194 farmer farmer_server              : INFO     -> harvester_handshake to peer 65f3fa0b0407a07da8ccf04dfa0f64c28f714726312aa051d3a8529390db4d7a
17:08:03.218 harvester src.plotting.plot_tools : INFO     Searching directories ['/home/user/slab1/plots']
17:08:03.227 harvester src.plotting.plot_tools : INFO     Found plot /home/user/slab1/plots/plot-k32-2021-01-11-17-26-bf2363828e469a3417b89eb98cfa9d694809e1ce8bef0ffd1d12853d4227aa0a.plot of size 32
17:08:03.227 harvester src.plotting.plot_tools : INFO     Loaded a total of 1 plots of size 0.09895819725716137 TiB

Maybe follow logs: tail -F ~/.chia/mainnet/log/debug.log. Chia is nice enough to rotate logs for you.

K Sizes


Since the release of Beta 14 on the 1st of October 2020. All the below data is outdated and obsolete. It only serve as historical data. One exception is the final .plot size of k values. To get some insight into the new features of the plotter check out this post in the Discussions forum.

k=32 is now the minimum plot size that will be eligible for mainnet at the end of the year. More here.

The 1.0.4 release changes almost all of the information below for the better. This blog post is a good overview until we can update this.

Storage requirements

K-sizeTemp. SizeFinal Size
K=32239 GiB (256.6 GB)101.4 GiB (108.9 GB)
K=33512 GiB (550 GB)208.8 GiB (224.2 GB)
K=341041 GiB (1118 GB)429.8 GiB (461.5 GB)
K=352175 GiB (2335 GB)884.1 GiB (949.3 GB)

When planning on how much plotting space is required, only calculate the temporary disk size requirement.

When stagger plotting, disk size requirement may change depending on which Phase the plotting is at.

Plots larger than k=32

There was an oversight in Beta 14. For plots larger than k=32 the default buffer will not be enough to complete a plot. For k=33 a -b 3077 is the absolute minimum needed with the rest of the defaults. A -b 3139 will have better results by completing far more sorts in memory. More recommendations for 34-36 coming soon.


There has been at least one k=37 plotted using the Beta 17 plotter. It required 9.9 TiB of temp space, used 130TB of total IO, and took 404.5 hours (16.9 days.)


There has been at least one k=38 plotted on 1.0b18.dev831. Approximate working space used (without final file): 21547.738GiB Final file size 7657.460 GiB Total time = 3986304.072 seconds. (1107.3 hrs) 2/23/21

Beta 17 Data

i7-9700K Desktop Windows

  • Processor: Intel(R) Core(TM) i7-9700 CPU @ 3.60GHz 8 Cores
  • Memory: 16GiB
  • Motherboard: Asus ROG STRIX Z390-H Gaming
  • Storage: -t Sabrent Rocket 2TB SB-ROCKET-NVMe4-2TB
kPhase 1 (min)Plot time (min)Plot size (GiB)GiB/minuteworking (GiB)CPU Utilization (phase 1)CPU Total-b settingVersionNote
34397.251,406.57429.880.3056228981176.478100%100%-b 12000 -u 128 -r 8b17
33181.17675.17208.830.309301735588.203100%100%-b 6000 -u 128 -r 8b17

i5-4690K Debian 10 Desktop

  • Processor: Intel i5-4690k (4 cores @ 3.9GHz)
  • Memory: 8GB DDR3 1600Mhz
  • Storage: 1TB Samsung 870 EVO SATA SSD
kPhase 1 (min)Plot time (min)Plot size (GiB)GiB/minuteworking (GiB)CPU Utilization-b settingVersion
32162.1422.43101.30.2398269.326101%-e -b 4000 -r 21.1.1
33896.03208.80.2330588.227103%-e -b 4000 -r 21.1.1

Beta 14 Data

The following are data collected from plotting using the older and slower beta beta versions.

i9-9900 Gaming Desktop, Z390

  • Processor: Intel(R) Core(TM) i9-9900 CPU @ 3.10GHz (turbo up to 5GHz)
  • Memory: 2x 32GiB DIMM DDR4 2666MHz
  • Motherboard: Asus TUF Z390-PRO GAMING
  • Storage: -t Intel SSD DC P4600 Series, 3.2TB NVMe, first run on 750GB Optane P4800X
kPhase 1 (min)Plot time (min)Plot size (GiB)GiB/minuteworking (GiB)CPU Utilization (phase 1)CPU Total-b settingVersionNote
3268.52248.12101.320.408345698286.57365%171.36%-b 4096 -u 128 -r 16b14single
32204.37596.60101.300.169795508286184.7128.6-b 5000 -u 128 -r 4b148 at once, 1.36 GiB/min total

mini ITX NAS build

  • Processor: Intel(R) Core(TM) i5-9600K CPU @ 4.20GHz
  • Memory: 2x 16GiB DIMM DDR4 Synchronous Unbuffered (Unregistered) 2667 MHz
  • Storage: -t Intel SSD DC P4600 Series, 3.2TB NVMe
kPhase 1 (min)Plot time (min)Plot size (GiB)GiB/minuteworking (GiB)CPU Utilization (phase 1)CPU Total-b settingVersionNote
32130.12359.65101.360.282286.647172.71123.08-b 5000 -u 128 -r 4 -tb14running 5 in parallel
32155.28389.45101.3260.260286.58150.33116.86-b 5000 -u 128 -r 4 -tb14
32144.07378.38101.320.268286.573159.03119.24-b 5000 -u 128 -r 4 -tb14

Fedora Server 32

  • AMD Ryzen 7 3800x
  • 128 GB RAM
  • LVM Software RAID-0, 2x NVME Gigabyte Aorus 1TB
kPhase 1 F1/Total (min)Plot time (min)Plot size (GiB)GiB/minworking (GiB)CPU Phase 1CPU Total-b-r-u-sVersion

Beta 8 thru Beta 13

These results from various machines should give a sense of how long and how much space a plot will take on different hardware. The first section is from Beta 1.8 or newer. Historical data is below and is currently still useful at the Beta 1.8 stage. Please add yours here or post the details in the #testnet channel of the Keybase Chat. The theory and process of plotting are described in the Chia Proof of Space Construction document.

estimated space = 0.762 * k * 2^k bytes

kspace GiBtemp GiBspace GBtemp GB

AWS EC2 r5d.8xlarge – Pre release Beta 12

  • Processor: 32 Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz
  • Memory: 256GiB
  • Storage: tempdir:, Inc. NVMe SSD (Ubuntu 20.04) finaldir:, Inc. NVMe SSD
  • ~ – MB/s write
kPhase 1 (min)Plot time (min)Plot size (GiB)GiB/minuteworking (GiB)CPU Utilization-b settingVersionNote
3084.9168.123.80.14267.398.11 %192 GiBpre 1.12
31178.1359.049.20.140135.095.52 %192 GiBpre 1.12
32399.5796.0101.20.127391.092.50 %192 GiBpre 1.12

Dell Inspiron Desktop

  • Intel Hexacore i5 8400
  • 8 GiB DDR4
  • Western Digital WD7500AYYS 750GB 7200 RPM
  • ~ write
kPhase 1 (min)Plot time (min)Plot size (GiB)GiB/minuteworking (GiB)CPU Utilization-b settingVersionNote
321526.1284253.52101.30.024529100 %.default1.9Using Native Window Plotter, not WSL2

Dell Inspiron Desktop

  • Intel Hexacore i5 8400
  • 8 GiB DDR4
  • Toshiba dt01aca100 7200 RPM – 1TB Hard Drive
  • ~ write
kPhase 1 (min)Plot time (min)Plot size (GiB)GiB/minuteworking (GiB)CPU Utilization-b settingVersionNote
321001.8652572.58101.30.039529100 %.default1.9Using Native Window Plotter, not WSL2

MacBook Pro (13-inch, 2019, Four Thunderbolt 3 ports)

  • 2.8 GHz Quad-Core Intel Core i7
  • 16 GiB 2133 MHz LPDDR3
  • ~ 2900 MB/s write
kPhase 1 (min)Plot time (min)Plot size (GiB)GiB/minuteworking (GiB)CPU Utilization-b settingVersionNote

Ubuntu 19.04

  • Intel(R) Xeon(R) W-2155 CPU @ 3.30GHz (10 cores)
  • 64 GiB PC4-21300 DDR4-2666V-R REGISTERED ECC
  • Western Digital 4 TB WD10EZEX
  • ~ – MB/s write
kPhase 1 (min)Plot time (min)Plot size (GiB)GiB/minuteworking (GiB)CPU Utilization-b settingVersionNote

Ubuntu 20.04.1 LTS

  • Intel(R) Xeon(R) E3-1270v6 CPU @ 3.80GHz (4 cores)
  • Samsung(R) M391A2K43BB1-CRC 32GB (2x16GB) PC4-19200 DDR4 2400Mhz ECC
  • Intel(R) P4510 NVMe SSD 1TB (2x1TB in RAID 1)
  • fio 1 MiB randwrite: ~800 MiB/s; fio 4 KiB randwrite: ~360 MiB/s
kPhase 1 (min)Plot time (min)Plot size (GiB)GiB/minuteworking (GiB)CPU Utilization-b settingVersionNote
32352.47854.27101.360.1187641.6683.85%200001.11used cli -f -p
32343.18838.89101.380.1209621.7184.43%200001.10used cli -f -p
32378.90869.49101.370.1166524.0385.24%200001.9used cli -f -p

Razer Blade Stealth 2018

  • Intel(R) Core(TM) i7-8550U CPU @ 1.80GHz, 2001 Mhz, 4 Core(s), 8 Logical Processor(s)
  • 16 GiB RAM
  • Samsung SSD PM981 MZVLB512HAJQ
  • Crystal – CDM 5 Write Seq: 1468 MB/s
kPhase 1 (min)Plot time (min)Plot size (GiB)GiB/minuteworking (GiB)CPU Utilization-b settingVersionNote

Intel Pentium CPU G4500 in WSL2 on ext4

  • Intel Pentium CPU G4500 @ 3.50Ghz – no AVX
  • 8 GB RAM
  • Samsung SSD 860 EVO 250GB
  • ? MB/s
kPhase 1 (min)Plot time (min)Plot size (GiB)GiB/minuteworking (GiB)CPU Utilization-b settingVersionNote

Intel Pentium CPU G4500 in Windows on NTFS

  • Intel Pentium CPU G4500 @ 3.50Ghz – no AVX
  • 8 GiB RAM
  • Samsung SSD 860 EVO 250GB
  • ? MB/s
kPhase 1 (min)Plot time (min)Plot size (GiB)GiB/minuteworking (GiB)CPU Utilization-b settingVersionNote

AWS EC2 r5dn.12xlarge

  • Processor: 48 Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz
  • Memory: 374GiB
  • Storage: tempdir: ramdisk of 310GiB (Ubuntu 18.04) finaldir:, Inc. NVMe SSD
  • ~ – MB/s write
kPhase 1 (min)Plot time (min)Plot size (GiB)GiB/minuteworking (GiB)CPU Utilization-b settingVersionNote

AWS EC2 i3en.large

  • Processor: 2 Intel(R) Xeon(R) Scalable (Skylake) processors with new Intel Advanced Vector Extension (AVX-512) instruction set @ 3.1 GHz
  • Memory: 16 GiB
  • Storage: 1 x 1,250 NVMe SSD
kPhase 1 (min)Plot time (min)Plot size (GiB)GiB/minuteworking (GiB)CPU Utilization-b settingVersionNote

AWS EC2 i3.xlarge

  • Processor: 4 Intel(R) Xeon(R) E5-2686 v4 (Broadwell) CPU @ 2.30 GHZ
  • Memory: 30.5 GiB
  • Storage: 1 x 950 NVMe SSD
kPhase 1 (min)Plot time (min)Plot size (GiB)GiB/minuteworking (GiB)CPU Utilization-b settingVersionNote

Raspberry Pi 4

  • Processor: Broadcom BCM2711, Quad core Cortex-A72 (ARM v8) 64-bit SoC @ 1.5GHz
  • Memory: 4 GB LPDDR4-3200 SDRAM
  • Storage: Samsung 860 EVO V-NAND SSD 1 TB (SATA to USB 3.0 connection)
kPhase 1 (min)Plot time (min)Plot size (GiB)GiB/minuteworking (GiB)CPU Utilization-b settingVersionNote
  • Storage: Seagate Backup Plus 10 TB (USB 3.0 connection)
kPhase 1 (min)Plot time (min)Plot size (GiB)GiB/minuteworking (GiB)CPU Utilization-b settingVersionNote

Pre Beta 8

incorrectly listed as GB – most should be GiB

MacBook Pro (13-inch, 2019, Four Thunderbolt 3 ports)

  • 2.8 GHz Quad-Core Intel Core i7
  • 16 GB 2133 MHz LPDDR3
  • ~ 2900 MB/s write
kplot time (minutes)plot size (GB)working (GB)CPU UtilizationNote
2882.15.5830.2769.4%some use
30406.523.812871.67%in use
3037723.812873.18%machine idle
31856.749.16262.092.29%idle – last 80%

iMac (Retina 4K, 21.5-inch, 2017)

  • 3.4 GHz Quad-Core Intel Core i5
  • 16 GB 2400 MHz DDR4
  • 1TB Fusion Drive (Actually attached USB 3.0 4Tb RAID 1)
  • ~ – MB/s write
kplot time (minutes)plot size (GB)working (GB)CPU Utilization

Ubuntu 19.04

  • Intel(R) Xeon(R) W-2155 CPU @ 3.30GHz (10 cores)
  • 64 GB PC4-21300 DDR4-2666V-R REGISTERED ECC
  • Western Digital 4 TB WD10EZEX
  • ~ – MB/s write
kplot time (minutes)plot size (GB)working (GB)CPU UtilizationNote

AWS EC2 r5.12xlarge

  • Processor: 48 Intel(R) Xeon(R) Platinum 8175M CPU @ 2.50GHz
  • Memory: 374GB
  • Storage: Memory tempfs (Ubuntu 19.10)
  • ~ – MB/s write
kplot time (minutes)plot size (GB)working (GB)CPU UtilizationNote
3142549.1526299.99%alpha 1.3

AWS EC2 r5dn.12xlarge

  • Processor: 48 Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz
  • Memory: 374GB
  • Storage: tempdir: ramdisk of 264GB (Ubuntu 18.04) finaldir:, Inc. NVMe SSD
  • ~ – MB/s write
kplot time (minutes)plot size (GB)working (GB)GB/minuteCPU UtilizationNote
3141249.14262*0.11999.99%actual working 267GB, chiapos 0.12.13
31408.449.14262*0.12099.99%actual working 267GB, speedy branch

MacBook Pro (15-inch, 2017)

  • 2,8 GHz Quad-Core Intel Core i7
  • 16 GB 2133 MHz LPDDR3
  • 251 GB (Flash Storage) Device Name: APPLE SSD SM0256L
  • ~ – MB/s write
kplot time (minutes)plot size (GB)working (GB)CPU UtilizationNote
3055923.79217.9461.65%alpha 1.0
3061423.8127.99261.13%alpha 1.1

MacBook Pro (15-inch, 2017)

  • Processor: 2,8 GHz Quad-Core Intel Core i7
  • Memory: 16 GB 2133 MHz LPDDR3
  • Storage: 1 TB (TOSHIBA HD)
  • ~ – MB/s write
kplot time (minutes)plot size (GB)working (GB)CPU UtilizationNote
30151223.838128.0527.59%alpha 1.0

Fedora Server 31

  • Processor: AMD Ryzen 5 3600 6-Core Processor
  • Memory: G-Skill 64 GB DDR4 3000MHz
  • Storage: GIGABYTE AORUS NVMe Gen4 SSD 1 TB
kplot time (minutes)plot size (GB)working (GB)CPU UtilizationNote
31571.549.15261.9971.17%beta 3.0 3 concurrent
32957101.36544.097.49%beta 3.0

Fedora Server 31

  • Processor: AMD Ryzen Threadripper 2950X
  • Memory: Corsair 128 GB DDR4 2133MHz
  • Storage: LVM-RAID0 (3 x Inland Performance Gen4 SSD 1 TB)
kplot time (minutes)plot size (GB)working (GB)CPU UtilizationNote
333093208.851096.0379.63%beta 3.0 2 concurrent

Chia Plotting Basics


First it is important to know that there are two very different parts of being a Chia farmer. There is creating the plots or plotting and then there is farming the plots. In this post we are going to focus on the process of creating your plots. The types of machines and storage space are very different than the types of hardware you ultimately want to use to farm. You can see some example farming rigs on our very useful repository wiki.

We initially recommend that you try plotting with what you have around. The only caution about that is that you want to limit the amount of plots you create that use your internal/consumer grade SSD as the temporary space. SSDs have very different wear lives and we have detailed information on SSD endurance.

You really never need to plot a plot with a k size larger than 32. Those who do plot larger are either doing them to show off (and we encourage this for fun) or to optimally fill the open space on a specific drive. A k32 will take up 101.3 GiB of space once completed but will need a total of 239 GiB of temporary space as it is being created. A single k32 plotting process never needs more than 239 GiB of space. One needs to be careful here as 239 gibibytes uses 1024 as its divisor where GB or gigabytes uses 1000 as the divisor. That means you will need 256.6 GB of temporary space and the final plot file will take 108.8 GB. A k32 plot can be done by one expert we know in just under 4 hours, but most experts are creating plots in 5 hours and most folks average around 9-12 hours.

Creating a plot is a process that will take RAM, CPU cycles, IO to your disks and it will use them differently in each of the four phases of plotting. Everyone wants a magic “right” answer or to use AI to figure out the optimal plotting strategy for their machine. However almost every machine is different along one of these parameters so you just have to try. Longer term we will be able query your machine and make some recommendations but that is not today. You really will have to test. And no, the experts in the various Keybase channels don’t know your best settings either.

Getting going

The first phase generates all of your proofs of space by creating seven tables of cryptographic hashes and saving them to your temporary directory. Phase 2 back-propagates through the hashes, phase 3 sorts and algorithmically compress these hashes in the temporary directory while starting to build the final file and phase 4 completes the file and moves it into your final plot destination.

One of the major bottlenecks is usually the total sustained write speed of the disk underneath your temporary directory. We recommend used datacenter SSD if you really want to go fast and not sacrifice consumer SSDs making plots. NVMe is faster than SAS and SAS is faster than SATA. This PC World overview of storage technologies can explain these acronyms and the differences. TBW, or terabytes written, is generally how SSD drive life is measured. One k32 writes 1.8TiB in non-bitfield mode and 1.6 TiB with bitfield enabled. More on bitfield in a moment.

Making the single fastest plot isn’t generally the best plotting strategy however. Often you’re getting amazing speed because you’re using the turbo core of that multi core processor. The folks who plot the most have shown that you should measure in TB (TiB if you’re old school like us) per day. The way to get the maximum TB/day is to plot lots of plots in parallel. Some of the top plotters use datacenter SSDs. Some use SAS drives. Raid 0 is often very handy to tie together a couple of small fast drives into one say 2TB partition so you could fit 5 k32 temporary spaces on that one virtual RAID drive.

All of that said, for my personal plotting I use a 2017 iMac and a 12TB Western Digital external drive on USB 3.0 for both temporary and final directory, and I get a k32 about every 10 hours.

Good assumptions

There are some good rules of thumb for now. These can change as we will be returning to making some plotting speed improvements after launch. First we need to explain bitfield versus no bitfield plotting. Originally, the plotter did not use bitfield back sorting. The bitfield back sort is theoretically faster than not using the bitfield and we already know that it saves 12% of total writes but requires more RAM. We have a hunch we can speed bitfield up 10% and make it work on more processors but that’s not in there yet. What we do know is that, as long as you’re ok with the 12% more total writes, no bitfield will work faster when SSD or fast SAS is your temporary directory. If your temporary directory is on a regular HDD, like mine is, bitfield is 20% faster than no bitfield. Older CPUs may not see the speed increase as much as noted above.

Returning to the rules, here are a few. Never touch the stripe size of 65536. No one has found a speed up over that value and we are likely removing it from the options list. (Update: as of 3/11/21 stripe size has been removed as an option.) You almost never want to use any bucket values other than 128. Less buckets requires more RAM for each plotting process. 64 buckets requires twice the RAM.

As far as number of threads are concerned you are generally going to want 2 to 4. More than 4 seems to have diminishing returns and 2 threads is a lot better than 1. More threads also require a bit more memory to successfully complete a plot. The threading is only used in phase 1 currently.

As of Chia 1.0.4, RAM requirements are almost identical between bitfield and no bitfield. This is a chart of the various RAM choices assuming a k32 with 128 buckets and 2 to 4 threads:

RAM MiB:MinimumMediumMaximum
No Bitfield90026403400

Below minimum your plot will fail. Medium is enough RAM that you’ll get most speed improvements, but not all. This is useful when you’re trying to get more plotting processes parallel and have limited RAM. Using anything over the maximum is wasting RAM as you will not plot any faster. We are pretty certain of the minimums and maximums but there is community debate about the medium values. We’ll update this chart accordingly as we have better data.

Mastering plotting

Most people start plotting from the GUI. You can successfully complete a couple of plots in parallel from there to get the hang of things. As people choose to get more serious they migrate to the command line. It is worth noting that Windows suffers 5-10% slower plot times versus MacOS or Linux for now.

Once you get some experience you will probably want to know how to create more and more plots in parallel. Luckily we have a replay on Some used servers and datacenter SSD, some bought used servers and SAS drives for temporary directories, some expand their consumer/gaming machines, and some focused on lots of smaller used machines. Many of them have compiled a spreadsheet of reference plotting hardware with plot speeds to help get you thinking about any hardware you might want to change or acquire and see how your plotting results measure up.

As you start parallel plotting you need to be careful to not over allocate memory when you are plotting. If you cause your operating system to swap, you are not going to be happy with your outcome. You don’t have to be as careful with thread count.

It is also a very common plotting strategy to plot on say your gaming machine and then move your plots to a Raspberry Pi 4 with a lot of USB ports. All you need is your same 24 word mnemonic on both machines. Alternatively you can just run a remote harvester on your Pi and have it connect to your gaming machine where you are running node and farmer and only have your private keys on one machine.

Learning more

Everyone trying to create plots should read through our repository FAQ. It really does answer 90% of the questions you might have about plotting (and farming.)

Once you have read the FAQ, you’ll find a supportive community in these channels on our public Keybase channels.

Keybase ChannelTopic
#beginnerFor those questions you are afraid to ask
#testnetFor all things testnet – an intermediate skill level
#plotting-hardwareThe expert plotters are here. Hardware, software and plotting strategy

Quick Start Guide

All configuration data is stored in a directory structure at the $CHIA_ROOT environment variable or at ~/.chia/mainnet/. You can find databases, and logs there. Optionally, you can set $CHIA_ROOT to the .chia directory in your home directory with export CHIA_ROOT=~/.chia and if you add it to your .bashrc or .zshrc to it will remain set across logouts and reboots. If you set $CHIA_ROOT you will have to migrate configuration items by hand or unset the variable for chia init to work with unset CHIA_ROOT.

If you are using the MacOS or Windows builds, your keys are created during the first run. We recommend saving the mnemonic. You can start plotting a plot file using the Plot tab or the command line. This can take a long time depending on the size of the plots (the k variable). To be competitive on mainnet you will probably have to have a few k=32 or larger plots but a k=32 plot currently takes about 10 hours to plot on an M.2 PCIe NVMe SSD and requires 232 GiB of temporary working space to create a final plot file of 101.3 GiB. Your likelihood of winning a given plot is only driven by the final size of files.

The minimum plot size is k=32. Plots created with Beta 8 and newer version of the chia software will work on mainnet.

If you want more peers and better network connectivity, you should also try opening port 8444 on your router so other peers can connect to you. Follow this guide but using port 8444 instead of 8333. This helps the network be more decentralized. For further details about sync issues and port 8444, visit the Resolving Sync Issues page.

Using the Command-line Interface (CLI)

Using the CLI with Chia gives you greater and more precise control. For a more details on the commands, read the CLI Commands Reference.


You can learn how to use the Graphical User Interface (GUI) in Beginners Guide.

You can start with the Command Line Interface (CLI) by checking the commands available in ~\AppData\Local\Chia-Blockchain\app-1.1.5\resources\app.asar.unpacked\daemon\. Try .\chia -h or .\chia plots -h for example:

  1. Open PowerShellOn start menu type “powershell” and press the enter key.
  2. Change Directory cdOn PowerShell type cd $env:localAPPDATA\Chia-Blockchain\app-1.1.5\resources\app.asar.unpacked\daemon\ and press the enter key.
  3. Read Chia helpOn PowerShell type .\chia -h and press the enter key.

You can view your logs by opening “.chia\mainnet\log\debug.log” with a text editor like notepad or see it as it runs in PowerShell by using Get-Content, Get-Content ~\.chia\mainnet\log\debug.log -wait.


There are commands available in /Applications/ Try ./chia -h or ./chia plots -h for example. You can view your debug.log as it runs in from Terminal, tail -f ~/.chia/mainnet/log/debug.log.

A handy trick is to add that directory to your path – export PATH=/Applications/$PATH. To make it persistent add the same line to your .bashrc or .zshrc


If you installed Chia with the Linux installer files, your chia executable should be in one of the following locations:



If you installed from source (using git), just activate and run chia directly.

Development/source builds

If you’ve installed via the installers you can skip these steps.

Remember that once you complete your install you must be in the Python virtual environment which you access from the chia-blockchain directory, or the Windows “Chia Blockchain” directory, or your home directory if you opted for a binary install. Enter the virtual environment with the command . ./activate. Both dots are critical and once executed correctly your cli prompt will look something like (venv) [email protected]:~$ with (venv) prepended.

Use deactivate should you want to exit the venv. If you’re not a fan of dots, an equivalent alternative on most platforms is source venv/bin/activate and you’ll see that method in places in this documentation.

Migrate or set up configuration files

chia init

Generate keys

Create some keys by running the following script if you don’t already have keys:

chia keys generate

Run a full node + farmer + harvester + wallet

To run a full node on port 8444, and connect to the mainnet, run the following command. Logs are usually at ~/.chia/mainnet/logs/debug.log or ~.chia\mainnet\logs\debug.log on Windows

cd chia-blockchain-gui
npm run electron &

Farmers are entities in the network who use their drive space to try to create blocks (like Bitcoin’s miners), and earn block rewards.

You can use the command line tools and change the working directories and output directory for plotting, with the “-t” (temp), “-2” (second temp), and “-d” (destination) arguments to the chia plots create command. -n 2 will create two plots of type k=32 and take about 12 hours on NVMe drives in the example below.

chia plots create -k 32 -n 2
chia plots check -n 30

Note that in the dev build the commands are chia plots create and chia plots check.

Run a timelord

Note If you want to run a Timelord on Linux, see Information on blue boxes coming soon.

Timelords execute sequential verifiable delay functions (proofs of time or VDFs), that get added to blocks to make them valid. This requires fast CPUs and a few cores per VDF as well as completing the install steps above and running the following from the chia-blockchain directory:

. ./activate
chia start timelord &

Alternatively run the local simulation

You can instead run the simulation, which runs all servers and multiple full nodes, locally. Note the the simulation is local only and requires installation of timelords and VDFs. The introducer will only know the local ips of the full nodes, so it cannot broadcast the correct ips to external peers. This should work on MacOS and Linux.

chia start sim


Ubuntu 20.04 LTS or newer, Amazon Linux 2, and CentOS 7.7 or newer are the easiest linux install environments.

UPnP is enabled by default to open port 8444 for incoming connections. If this causes issues, you can disable it in config.yaml. Or you can run this command: chia configure -upnp false Some routers may require port forwarding, or enabling UPnP in the router’s configuration.

Install instructions

Minimum Specs

The minimum supported specs are that of the Raspberry Pi 4:178,553

  • Quad core 1.5Ghz CPU (must be 64 bit)
  • 2 GB Ram
  • Python 3.7 and above

Drive format support

Chia plot files are at least 108GB in size (for K32). To plot successfully requires drives formatted to support large files; e.g. NTFS, APFS, exFAT, ext4, etc. Do not use drives with FAT formatting (FAT12, FAT16, or FAT32) or else plotting will fail. Future versions of Chia will check for unsupported drives, but for now it’s up to each user to check their drive format.

Sleep kills plots

The Chia plotting process takes multiple of hours to complete. If the computer or hard drives goes to sleep during the plotting process, the plotting fails and you will need to start over. Please ensure all sleep, hibernate and power saving modes for your computer and hard drives are disabled before starting the Chia plotting process. In the future, Chia will have resume plot feature. In the meantime, if you do get a failed plot, delete all *.tmp files before starting a new plot.

Updating from Release Candidate to 1.0:

Keys and configs from RC3 and newer should automatically migrate. For more details, read the FAQNo testnet/TXCH coins migrate to mainnet. Mainnet coins are forever, however.


Install the Windows installer – Chia Blockchain Windows

As the Chia code signing certificate is new you will likely have to ask to keep the download and when you run the installer, you will have to choose “More Info” and “Run Anyway” to be able to run the installer. There is no need to use the command line. Some Windows anti-virus applications are seeing the download as a false positive. You can see the entire source code and build method here so we think it’s safe for you to ask those tools to ignore it. Running the installer while plotting on a previous version will stop your plotting process, so be careful.


macOS Mojave (10.14.x) or newer is required.

Install the macOS .dmg installer – Chia Blockchain MacOS

When the installer first runs it will import or create multiple keys and add them to the macOS keychain. You may be prompted up to 3 times for your password. We suggest choosing “always allow.”

To build a development version, make sure brew is available before starting the setup and that python 3.7 or newer is installed.

git clone -b latest
cd chia-blockchain

. ./activate


cd chia-blockchain-gui
npm run electron &


We have an experimental GUI installer (x86_64) for Ubuntu 18.04 Desktop and newer and Debian Buster w GUI and newer. There is also an experimental GUI installer for ARM64 Ubuntu and Debian/Raspberry Pi OS 64. Binary CLI tools can be found in /usr/lib/chia-blockchain/resources/app.asar.unpacked/daemon/

Follow below install instructions for Ubuntu 20.04 LTS. If you are installing on Ubuntu 18.04 LTS you should use Python 3.7 instead: sudo apt-get install python3.7-venv python3.7-distutils python3.7-dev git lsb-release -y

sudo apt-get update
sudo apt-get upgrade -y

# Install Git
sudo apt install git -y

# Checkout the source and install
git clone -b latest --recurse-submodules
cd chia-blockchain


. ./activate

# The GUI requires you have Ubuntu Desktop or a similar windowing system installed.
# You can not install and run the GUI as root


cd chia-blockchain-gui
npm run electron &

To Update/Upgrade from previous version

cd chia-blockchain
. ./activate
chia stop -d all
git fetch
git checkout latest
git reset --hard FETCH_HEAD

# If you get RELEASE.dev0 then delete the package-lock.json in chia-blockchain-gui and again

git status

# git status should say "nothing to commit, working tree clean", 
# if you have uncommitted changes, RELEASE.dev0 will be reported.


. ./activate

chia init

# The GUI requires you have Ubuntu Desktop or a similar windowing system installed.
# You can not install and run the GUI as root
cd chia-blockchain-gui
git fetch
cd ..
chmod +x ./

cd chia-blockchain-gui
npm run electron &


Sometimes stray daemons left over from previously running processes will cause strange bugs/errors when upgrading to a new version. Make sure all daemons and chia processes are killed before installing or upgrading.

This is normally done by executing chia stop -d all from the upgrade example above.
But it doesn’t hurt to double check using ps -Af | grep chia to make sure there are no chia processes left running. You may have to manually kill the chia daemon if an install and chia start was performed without first running chia stop -d all

If all else fails, rebooting the machine and restarting the chia daemon/processes usually does the trick.

CentOS/Red Hat/Fedora

We have an experimental GUI installer for RH/CentOS 8.0 and Fedora 28 and newer.

sudo yum install epel-release -y
sudo yum update -y

# Compiling python 3.7 is generally required on CentOS 7.7 and newer
sudo yum install gcc openssl-devel bzip2-devel zlib-devel libffi libffi-devel -y
sudo yum install libsqlite3x-devel -y
# possible that on some RHEL based you also need to install
sudo yum groupinstall "Development Tools" -y
sudo yum install python3-devel gmp-devel  boost-devel libsodium-devel -y

sudo yum install wget -y
sudo wget
sudo tar -zxvf Python-3.7.7.tgz ; cd Python-3.7.7
./configure --enable-optimizations; sudo make -j$(nproc) altinstall; cd ..

# Download and install the source version
git clone -b latest
cd chia-blockchain

. ./activate

# The GUI requires a windowing system to be installed.
# You can not install and run the GUI as root

cd chia-blockchain-gui
npm run build
npm run electron

# Or install from binary wheels
curl -sL | sudo bash -
sudo yum install -y nodejs

python3.7 -m venv venv
ln -s venv/bin/activate
. ./activate
pip install --upgrade pip
pip install -i miniupnpc==2.1 setproctitle==1.1.10

pip install chia-blockchain==1.1.6

Or, combining the last two steps into one, try

pip install --extra-index-url chia-blockchain==1.1.6 miniupnpc==2.1


You can run chia-blockchain in Ubuntu 20.04 LTS via WSL2 on Windows.

NOTE: WSL2 plotting is currently only slightly faster than plotting on the native windows client. WSL2 requires significant tweaking to set up correctly. If you find that daunting, it’s probably easier to just use the native windows client.

You can not run the GUI as WSL2 doesn’t yet support graphical interfaces from WSL2.

Check if you already have WSL2 or WSL1 installed:

From PowerShell, type:

wsl -l -v

If you get a listing of help topics for wsl commands, you have WSL1, and need to upgrade. To upgrade, follow the instructions here. If you get a blank result or a listing of installed Linux versions, you have WSL2 and are OK to proceed.

If WSL is not installed:

From an Administrator PowerShell:

dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart
dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all

You will be prompted to reboot.

Installing a new WSL2 instance:

Install Ubuntu 20.04 LTS from the Microsoft Store and run it and complete its initial install steps. You now have a linux bash shell environment that can run linux native software on Windows.

Then follow the steps below which are the same as the usual Ubuntu instructions above with a target of Python 3.8.

sudo apt-get update
sudo apt-get upgrade -y

git clone -b latest
cd chia-blockchain


. ./activate

Running a standalone Windows wallet gui is deprecated but may return in later versions. You can run the Windows version and share keys. You can also plot in WSL2 and migrate the plots to a Windows farmed plot directory.

Increasing the WSL Maximum Storage Capacity

WSL2 uses a Virtual Hardware Disk (VHD) to store files, and it automatically resizes as files grow. However, the VHD has an initial maximum size of 256 GB. Therefore, the default WSL2 VHD is probably only capable of plotting k=30 plots. To plot anything larger, you will need to increase the maximum allowable size. Follow the guide here.

Setting a maximum limit to WSL2 memory access

If you try plotting Chia in WSL2 without limiting the memory access, WSL2 will use 100% of your available machine’s memory, and your computer will get bogged down and begin swapping memory to your hard drive. This will severely cripple your plotting speeds. To set the maximum memory that WSL2 is allowed to use, create a configuration file as described in this guide.

WSL VHD Plotting Nuances

Plotting within WSL2 can write to either the native VHD (which is EXT4) or to any other drive, which can be NTFS or any other FS-type. Writing to the native VHD is faster than writing out to another drive.

Plotting uses three commands for directory control:

-t for initial temp directory. Phases 1 and 2 happen here.

-2 for secondary temp directory. Phase 3 (compression) happens here.

-d for final destination. Phase 4 happens here.

Plotting works such that -t and -2 require the exact same amount of storage space. Therefore, if -t and -2 point to the same drive, that drive needs 2x the final file size + 1x the max working file size.

For maximum speed, -t and -2 should be inside the WSL2 filesystem. Something like: -t ~/chia_temp -2 ~/chia_temp. Just beware that the WSL2 VHD will need a much larger maximum capacity.

-d can point to any other drive for the final destination.

Amazon Linux 2

sudo yum update -y
sudo yum install python3 git -y

git clone -b latest
cd chia-blockchain


. ./activate

# Or install chia-blockchain as a binary package
curl -sL | sudo bash -
sudo yum install -y nodejs

python3.7 -m venv venv
ln -s venv/bin/activate
. ./activate
pip install --upgrade pip
pip install -i miniupnpc==2.1 setproctitle==1.1.10

pip install chia-blockchain==1.1.6

Other install methods and environments

You need Python 3.7 or newer.

Chia strives to provide binary wheels for modern systems. If your system does not have binary wheels, you may need to install development tools to build some Python extensions from source. If you’re attempting to install from source, setting the environment variable BUILD_VDF_CLIENT to N will skip trying to build Timelord components that aren’t very cross platform, e.g. export BUILD_VDF_CLIENT=N.

Create a virtual environment

Your installation goes inside a virtual environment.

There are lots of ways to create and manage a virtual environment. This is just one.

python3.7 -m venv venv
source venv/bin/activate
pip install --upgrade pip

Wheels can be in source or binary format. Binary wheels are specific to an operating system and python version number. Source wheels require development tools.

Chia hosts some binary wheels that are not available from PyPI. This step is optional, but it may succeed where building from source can take a while or fail in hard-to-debug ways. If wheels are not available for your system, this step will fail. But you can try it anyway.

pip install -i miniupnpc==2.1 setproctitle==1.1.10

Install chia-blockchain.

pip install chia-blockchain==1.1.6

Before you use chia-blockchain in future, you must “enter” your virtual environment.

source venv/bin/activate
chia -h


To join the testnets, we recommend you keep a separate environment by prepending CHIA_ROOT="~/.chia/testnetx" to all of your cli commands. For example, CHIA_ROOT="~/.chia/testnet7 chia init. An easier way to do this, is to just export CHIA_ROOT="~/.chia/testnet7" so all commands will use testnet7 instead of mainnet. You should also update all config values to the testnet values, by doing chia configure -t true.

Chia Mining Beginners Guide

Before You Begin

Keep it simple. Focus on learning what Chia is and how to make one plot. Once you do that, move on to doing more. It’s easier to start simple than to do too much and get confused about what went wrong.

The Basics of Chia to Get You Started

Chia – Short Version

Chia is a new blockchain technology where your computer creates plot files that you can farm to potentially earn Chia (XCH) coins.

Chia – Long Version

Chia is a new type of cryptocurrency that is based on the capacity of pre-stored random-looking data that the user creates and stores in files called plots. With Chia a very low resource-intensive process checks plot files for proof of space and time. This makes Chia very fast and green. It is an improvement over proof of work blockchains, which rely on fast graphic cards and custom machines doing millions of calculations per second and wasting a lot of electricity. Chia also has many improvements to scripting, scripting environment, cryptography, usability, and scalability, and aims to be a simple, secure, and powerful blockchain.

The Chia software is made up of several parts called daemons. Each daemon does different things. The daemons important to beginners are:

  • node – This syncs your computer with the blockchain
  • farmer – The farmer sends out proof requests to the harvester
  • harvester – The harvester checks your plots to see if they satisfy the proof. If you have the best proof, you win coins.

What to do as a beginner

For now, focus on installing the Chia software, setting it up properly, and learn how to make plots. There are two main things to get working:

  • Making sure you are connecting to other nodes (other computers with the blockchain) and syncing with them.
  • Starting making plots and farming.

The simplest way to start with Chia is to install the Chia software on the operating system of your choice and run the GUI (Graphical User Interface). The Windows version automatically starts once installed, and the Mac just needs to be opened from the Applications directory. Once the application is opened, it loads and starts to sync with the rest of the network and blockchain. As of this writing, fully syncing can take 4-6 hours and this will increases over time as the blockchain grows. Basically, you are syncing with everyone on the network, downloading the whole blockchain, which includes all transactions ever processed on the network. The Chia blockchain database copy will be stored on your computer. Everyone with Chia installed on their computer also has a copy.

The Basics of Farming

Farming just means you have some plots and have the Chia software checking them periodically to see if they win a proof.

Gigabytes (GB) vs Gibibytes (GiB): You are going to see the unit GiB used a lot. Just know that 1 Gibibyte is equal to about 1.07 Gigabytes (GB). Most hard drives are talked about with GB so please keep that in mind.

Once Chia is installed, users will use the Chia application to create plots. Depending on your hardware it can take 4-12+ hours to create a plot. Each approximately 101 GiBs in size (108 GB). The user stores these plots on computer equipment and then farms the created plots for the potential to earn coins.

Inside each plot is a large number of pre-formulated calculations stored in large table (spreadsheet) of blocks called (hash) cells. You win potential coins by providing the winning pre-formulated (hash) code to allow the transaction to occur. The winning transaction is very quickly done within 2-3 seconds and the user is compensated with coins to facilitate the transaction. Plots have many (hash) cells inside so if one wins there is still many left that can win. In other words, you do not need to delete a plot if it wins you coins. Plots can keep earning you coins. Plots are estimated to last over 5 years.

The CLI – Command-line Interface

The Chia CLI is the more advanced way to use Chia. The CLI can do everything the GUI can do and more (like better utilize your hardware to optimize plotting). It is recommended you start with the GUI to understand the basics of Chia before starting to use the CLI.

Setting Expectations

Once you have completed plots and are farming, you will see “Time to Win Coin” in the farming tab. Whatever time it shows here is just an estimate. It might take 3 to 4 times longer than the time shown. For example, if it shows 2 days, it might take 5 or 8 days, sometimes even more to earn your first coin or partial coin. This is normal as luck plays a role over the short run. As you add more plots, the “time to win” gets a little more accurate and closer to the estimated time.

How to Get Help

  • Read over the documents in this Wiki first. Most of the information you need is here already.
  • Get support on the Chia Keybase chat channels. #beginner and #support is where you can get help
  • Submit an issue here on Github

The GUI – Graphical User Interface

Full Node Tab in the GUI

This shows the blockchain movement. It shows that you are in sync with the blockchain. A copy of the blockchain is stored on your computer. You have a live copy that is continually syncing with everyone else in the network.

  • Blocks : This is the blockchain working
  • Connections : Those are the connections to you and other users and their computer (nodes)

Wallet tab

You will see your Chia coins here as they are won

  • History : you can see the time/date you earned coins or partial coins

Plots tab

This is where you create plots. The accepted plot size starts at 101 GiB each. Called a k32 – 101 GiB/109 GB plot.

  • GiB : is gibibytes and the old school way computers measured space. The new hotness – especially from hard drive manufacturers – is to measure in gigabytes. Since gigabytes are based on 1000 and gibibytes are based on 1024, GB is always 1.074 times larger than GiB.
  • When you plot : You can think of each plot as a collection of bingo cards, which have a chance of winning blocks, and thus winning you coins.Your computer creates these large 101 GiB plot files (approx 108 GB – gigabytes). Inside are large tables (like Excel spreadsheets) where each cell has a random pointer to another cell in the table. This is what the computer is doing, and why it takes so long to create the plot. It is running calculations and putting the “answers” in these millions of cells. The expected life for a 101 GiB – k32 plot to be eligible on mainnet is about 5 to 10 years, for now. There are different sizes of plots. For now, only work with k32 plots. k33 and above are not necessary.

Farm tab

This will show you how many plots you have created. On the top it will show how many Chias have been farmed. It also shows how many GiB of plots you have on the network. For example, you have 2 plots of 101 GiB created. Then it shows on Top left “Total size of Plots” as 0.2 TiB. This means you offer 0.2 TiB much storage of formulas to the Chia network. It is calculated as you have 101 GiB x 2 = 202 GiB.

  • Latest Block Challenges : This shows the latest challenges and signage points, which can be thought of as mini lotteries. Every 9 seconds, there is a new signage point, which means there is a new opportunity for you to check your plots and see if you’ve won. Every other signage point will be a winner for someone on the network so there is a new block created about every 18 seconds.
  • Last Attempted Proof This is important: It is a 2 step process. Step 1 plot passes filter test. Step 2 – Selected Plot is checked for winning hash. What this looks like in the GUI: In the Last Attempted Proof section you have a list of five lines. Suppose you have 157 plots – each of the five lines read 0/157. Once in awhile a plot might get selected. If a plot is selected or a 2nd plot is selected that is good news and the number changes to 1/157 or 2/157 maybe 3/157. After passing the filter, each selected plot will go through a “quality lookup,” which does approximately 7 reads on your plot, and tells you whether the plots have won. If you won, it does not show any indication as the transaction is done quickly. Your wallet increases.

Once that match shows on the first line, it will move down to lines 2-5, then if another plot passes step 1, it starts at the top also, and moves its way done the filter process.

Winning is very rare, and on average one person wins in the whole world every 18 seconds. On every signage point (9 seconds), all of your plots are checked to see which ones passes the plot filter. Approximately 1/512 of all plots will pass the plot filter for each challenge, so here you can see how many of your plots passed. However there are 4,608 chances to win 2 chia every day.

If for some reason those lines stop moving that is another indication you are not in sync with database and need to resync—see below.

Using the GUI

Create a plot

  1. Click on green button- top right “Add a Plot”
  2. Starting size plot is k 32 (101 GiB). You need a temp storage location of at least 239 GiB (256 GB) to create the plot.
  3. Chose number of plots — you can select quantity to create.
    1. Plot to Queue : Means if (5) is selected it will plot #1, then when finished will start #2
    2. Plot in Parallel : means running multiple plots at same time. Make sure you have enough temp storage for combined total.
    3. Advanced options : The default values appear for your selected plot size, as a beginner try to leave the defaults
      1. RAM Max Usage: More memory slightly increases speed, if you assign too little (less than 4,000 for a k 32) or too much (more than you will have available) the plot might fail during the process.
      2. Number of Threads: Default is 2.
      3. Buckets: Default is 128, more buckets decreases the amount of RAM required and usually increases the speed of plotting.
      4. Queue name: This is useful to mix parallel and series plotting. IE: If you want to do 2 plots at a time, 10 plots in total, you can make 5 plots to Queue name: “My First Queue” and after that add another 5 plots to Queue name: “My Second Queue”.
  4. Select Temporary Directory: This is where plots are created. About 128 temp files will be created (depending on buckets), then compacted to one plot file. This creation grows to 239 GiB (256 GB) and when finished it will be compressed to a single k 32 plot (101 GiB).
    1. It’s recommended to use a SSD drive or NVME drive for this work but make sure you are aware of SSD Endurance.
  5. Select Permanent directory—once the plot is created—it will go to this location to be farmed to earn chia coins. Storage will fill quickly due to size of plot. Storage can be internal or usb connected drives. Networked drives can work but could congest your local network or be to slow to respond for rewards (should be less than 30 seconds). Plan ahead—storage fills quickly.
  6. Click create plot to start process.

How Plots are created

Creating a plot is time consuming with an average of 9-20 hours on a normal computer and 4-8 hours on a high end machine. There are 4 phases that does operations in 7 tables.


  1. Computing tables 1 to 7: It creates the buckets (default: 128) as files on your temp directory, when the 7 tables are computed the plot time progress is about 42%
  2. Back propagation tables 7 to 1: When the 7 tables are back propagated the plot time progress is about 61%
  3. Compression of tables 1 to 7 in pairs: When the 7 tables are compressed the plot time progress is about 98%
  4. Write checkpoint tables: Transfers your plot to your permanent drive. It will delete all the files in your temp storage and this completes the progress to 100%
The suggestion is to use an added SSD or NVME storage to create plots and not the primary hard drive (specially for non replaceable NVME like on some Macs or Windows Laptops) If for some reason a plot fails to complete- it has to be deleted by deleting all of its temp files. Be careful that you don’t delete the temp files of another plot that’s being plotted.


Proof: It is found inside the PLOT. Millions of “excel blocks” with formulas called proofs of space. The Chia software is designed to work on a lottery system. A key element to winning the lottery of earning coins is that the more plots you have, the more proofs you have, and therefore the higher chances of winning. Someone with 1% of all the plotted space, will win about 1% of all the blocks. There are about 4608 blocks per day, each with 2 chia, so 9216 chia are created per day.

The Chia farming software gets a challenge, lets say 2021. It’s going to look through lookup tables on the front of the plots. Find the closest to 2021 and this is where the time comes into play– That proof (excel block hash) has a certain quality, and only proofs that are of a certain quality or better are eligible for winning.

What makes Chia different from proof of work blockchains— is the consensus algorithm called proof of space and proof of time. Basically as after the farmer creates a proof of space and a block, other computers called timelords add proofs of time to the block, which is a cryptographic proof that says that a certain amount of time (like 30 seconds) has passed. So instead of the whole world mining at the same time, only a few computers are “mining” for each proof of space that won. Since these are all cryptographic proofs, they cannot be forged or broken, making the consensus extremely secure.

In Chia, the only electricity required is the electricity to create the plots, and to run the hard drives, which is on the order of 10 watts to power, plus CPU power required to run a full node (which is very light). In comparison Blockchains like Bitcoin and Ethereum rely on huge farms of GPUs ( 300W each GPU), or ASICs (hundreds or thousands of watts per machine) to secure the blockchain. You can think of proof of work, as millions of computers “making” lottery tickets by using electricity, but each ticket can only be used once. Chia will use vastly less electricity as each plot will last over 5 years, and the only electricity required is the initial setup (plotting) and 10W for farming a drive.

Computer Hardware

SSD drivers: Many people are using SSD drives to create plots— or NVME drives. Minimum of 1 Tb each is recommend if you want to plot more than 1 plot at a time.

On an older computer you can purchase a pcie adapter card-to take NVME/SSD drive as the new temp folder. This is internal to the PC. Some have tried to use a usb or firewire attached NVME/ SSD with some success. The first plot is sometimes created with 6 hrs each, but doing multiple plots slows to 8 hrs each. This pertains to creating the temp files.

One item to plan for is storage of plots as they fill storage quickly. As more plots are created, the discussions start to turn to terabytes of data storage not gigs of storage. Many use usb attached external drives for storage, or internal drives or external rack storage with many drives.

Sync Issues – look on Full Node tab

Look at the date/time indicated compared to your computer. If there is a 30 min difference and it has not caught up—on the windows menu—click View/Force reload. It will take 5 minutes and should restart the sync mode. It will make you click your key code button again to get in. It does not affect the plotting you are doing.

Groups to join on the chia_network.public Keybase chat:

  • #announcements — most important as it tells you of new versions
  • #beginner — read this one from the start — many questions are answered
  • #farming hardware
  • #general
  • #plotting-hardware
  • #random
  • #testnet

Frequently Asked Questions

If power goes out what happens. Answer- In the chia software, the plots that currently being built are now non operational. When you start Chia they will be gone and need to be restarted. One item to do is to go into your temporary storage and delete all those .tmp files it created. This is the one time it will not self delete those files if a new plot is started. Not deleting them may cause that storage device to run out of room when it starts 1 or multiple plots. All your existing plots are “safe” in their existing storage.

Can I use USB 3.0 cable connected to SSD/NVME running the Temp files. Answer- On Windows – it has not worked well- the communication speed is not fast enough, sometimes the usb turns off, then the plot is not useable. It’s possible to run 1 plot, but limiting when trying to process multiple plots. Most are installing PCIe adapters to SSC/NVME and that solves the issue. The mac has very fast communication to do the first plot, – many others are saying that they can do 2 plots but process time increases dramatically. Technology is constantly changing so continue to do research and ask in the chat rooms.

Once a hash is used from a plot– does it need to be deleted. Answer– no– an example is , a plot has 300,000 hashes that the user created. If one is used, there are enough to last an estimated 5 years.

Farmer vs Harvester: Harvester checks the plots and reports the results to the farmer, farmer then submits the results to the blockchain

Peak Blockchain and checking if Chia is in sync

The chia blockchain software : Every user has copy of the blockchain on their PC and the goal is that everyone is in sync or very close. Click on the Full Mode tab, scroll down to see the connected Nodes/ PC. If the time and date is off by 30 minutes then the software is not synced to blockchain or others. Multiple ways to check– on Full node — look at peak height and date/time— then go below and look at connections and your peak should match the other computers. Also the peak should be close when you click on wallet tab with that wallet peak number. The wallet peak number sometimes is off by 10 numbers. If off by several hundred it’s not in sync.

On the GUI– on the top menu bar — click on View then Force Reload. It will take about 5-10 minutes, to re-sync. Your keys will come up again to click to enter Chia. It will not affect your plotting.

How to tell if Chia is working on Windows GUI

When you are first operating Chia and wondering if the software is working- here is some information to keep you informed. All of the chia programming is in a file called config.yaml located in c:/Users/ (Your username)/.chia/mainnet/config.yaml

Shut down Chia software before config access. Open Config with notepad. In the middle * log_level: WARNING * change wording of WARNING to INFO. Save File and exit. Start up Chia– give it 20 minutes to run

Can access the log files and read activity, while Chia is running. It’s located in c:/Users/ (Your username)/.chia/mainnet/log/debug.log Log files are very informative. Once a log fills to 20mb another is created. If there are too many you can delete some of them.

Inside what you are looking for are these lines 07:02:41.663 harvester src.harvester.harvester : INFO 1 plots were eligible for farming f53c496e80… Found 0 proofs. Time: 0.00500 s. Total 8 plots

This means Chia is working– The filter system is 2 parts. Chia found that 1 plot passed the (1st) part, now it looks inside to determine if a pre-formulated “proof” will be able to do a transaction in fastest time (2-3 seconds) if it secures one in your plot then you win 1 proof means you won a coin. Many times it will say 0 proofs. But it shows it’s working. This is where luck/time comes into play. At the end of that line it will indicate how many plots the software registers.

What is normal information in a log file

Below is a copy of normal information from a log file. :

9:32:00.322 full_node full_node_server : INFO <- new_signage_point_or_end_of_sub_slot from peer 68b376e5846696df3510822ea527d0899ac6183f261e8858119235cd24903720

9:32:00.278 farmer farmer_server : INFO <- new_signage_point from peer 62d37909657e183dcd702b66d0e694474f907361f5981eceaba00878e84419c4

09:32:01.806 full_node full_node_server : INFO -> respond_peers to peer e5b7f06ba6ece8698917e0e22971aef8602972de81efe379d693b2baa0dffc24.

09:32:08.063 full_node full_node_server : INFO -> request_signage_point_or_end_of_sub_slot to peer b567363c3a96c13366ef2dbff2e080da77f310875a8beda7c1c07246173c3a06.

09:32:08.202 harvester harvester_server : INFO <- new_signage_point_harvester from peer 5bfd9af9bc76270cf76746255db9a435dca56b9adb37f5d1daec71e3c699c807

09:32:08.211 harvester src.harvester.harvester : INFO 0 plots were eligible for farming fec1fff66e… Found 0 proofs. Time: 0.00200 s. Total 8 plots.

The last line again shows at that current time of 09:32:08.211- that on this machine, of the 8 plots farming 0 plots were eligible. It still means the software recognized the plots and it’s working.