* Next, you want to get the source code on your computer. Head over to the repository you just forked, and click the `Clone or Download` button. We want to clone the source code, so we can make changes, then push it back up to GitHub.
* It should look something like this:
* Now, take this URL shown, and copy it.
* Next, you will need to download a git client. If you are a windows user, I would suggest [Git for Windows](https://gitforwindows.org/), whilst if you are a Linux or Mac user, you should have this either already installed, or can install it from your repos or with brew.
* Once you have opened up git bash or a terminal, you should be able to type `git clone URL`, where `URL` is the link you copied earlier, from GitHub.
* It should look something like this:
* Great, now the code is on our computer. We're almost ready to start changing it!
### Compiling
First, it might be a good idea to try compiling our code, so we can mess around with it later.
Just incase this guide gets outdated, you can always find the latest instructions on how to compile Kryptokrona on our [GitHub](https://github.com/Kryptokrona/Kryptokrona#how-to-compile).
#### Linux
**Prerequisites**
* You will need a few dependencies for the build, most notably, cmake, make, gcc, g++, and boost.
* On ubuntu: `sudo apt-get install -y build-essential python-dev gcc g++ git cmake libboost-all-dev`
**Building**
* `cd Kryptokrona`
* `mkdir build`
* `cd build`
* `cmake ..`
* `make`
* The binaries will be placed in the `Kryptokrona/build/src` folder.
#### Apple
**Prerequisites**
* Ensure you have brew installed. If you don't, you can install it like so: `/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"`
* Now we've got brew installed, we can install the dependencies.
* `brew install cmake boost`
**Building**
* `cd Kryptokrona`
* `mkdir build`
* `cd build`
* `cmake ..`
* `make`
* The binaries will be placed in the `Kryptokrona/build/src` folder.
#### Windows
**Prerequisites**
* Install [Visual Studio 2017 Community Edition](https://www.visualstudio.com/thank-you-downloading-visual-studio/?sku=Community\&rel=15\&page=inlineinstall)
* When installing Visual Studio, ensure you install `Desktop development with C++` and the `VC++ v140 toolchain` when selecting features.
* The option to install the v140 toolchain can be found by expanding the `Desktop development with C++` node on the right. You will need this for the project to build correctly.
* Install [Boost 1.59.0](https://sourceforge.net/projects/boost/files/boost-binaries/1.59.0/), ensuring you download the installer for MSVC 14
**Building**
* From the start menu, open `x64 Native Tools Command Prompt for vs2017`
* `cd This is how fast you want blocks to be. In Kryptokrona, we have blocks on average every 30 seconds. If you wanted blocks to be every 2 minutes, you would set this to be: * `const uint64_t DIFFICULTY_TARGET = 120; // seconds`
**`const uint64_t CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX = 3914525;`**
This defines what the addresses will start with. In Kryptokrona, this decodes to `XKR`. So how do we get this prefix? We can use this [handy tool](https://cryptonotestarter.org/tools.html).  Scroll down to the prefix generator, and enter your desired address prefix. Note that some characters are disabled, so you may not be able to get the perfect prefix. For example, `aPPLE` is allowed, but `APPLE` isn't. You may note that XKR's prefix is a number, while the output of this generator is not. These values are in hex format, and will automatically be decoded into a number when compiled, though you can use any standard hexadecimal to decimal converter to change the prefix into a number if you prefer. So, if we wanted our prefix to be 'aPPLE', we would set this to be: * `const uint64_t CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX = 0x1e1f8cc7;`
**`const uint32_t CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW = 40;`**
This value defines how many blocks need to be followed in the current chain before releasing the reward for mining a block for spending. We would suggest you set this value to be roughly equal to 20 minutes - in Kryptokrona's case that's exactly what we have - 40 blocks \* 30 seconds = 20 minutes. If you have a block time of 2 minutes for example, we would set this value to 10. * `const uint32_t CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW = 10;`
**`const uint64_t MONEY_SUPPLY = UINT64_C(100000000000000);`**
This line is a pretty significant one. It determines the max supply of coins your cryptocurrency will have. In Kryptokrona, this is 1 trillion XKR, but as previously mentioned, all these values are in *atomic units*, so this value also includes the amount after the decimal point. Thus, this value is 1 trillion \* 100, as Kryptokrona has 2 places after the decimal point. Therefore, we suggest you decide how many decimal places your coin has, before filling in this value. If you want your coin to have 6 decimal places, and the total supply to be ten thousand (10,000), the MONEY\_SUPPLY value would be: `10^6 (or 1,000,000) * ten thousand (10,000) = 10000000000`. So, we would then pop this value in to give us: * `const uint64_t MONEY_SUPPLY = UINT64_C(10000000000);`
**`const uint32_t ZAWY_DIFFICULTY_BLOCK_INDEX = 187000;`**
This section will cover all of these, since they are all related: ``` const uint32_t ZAWY_DIFFICULTY_BLOCK_INDEX = 187000; const uint64_t LWMA_2_DIFFICULTY_BLOCK_INDEX = 620000; const uint64_t LWMA_2_DIFFICULTY_BLOCK_INDEX_V2 = 700000; const uint64_t LWMA_2_DIFFICULTY_BLOCK_INDEX_V3 = 800000; ``` These values set the heights where the different difficulty algorithms go live. A difficulty algorithm determines how hard it is to mine a block at a given height. If there are more people mining, it gets harder, and visa versa. This ensures blocks are found on average every 30 seconds (In XKR's case). Difficulty algorithms are pretty hard to write, so we have quite a lot of revisions! We strongly suggest you use the latest version, to make you more resistant to pulse mining and timewarp attacks. The below section will activate each one at the first available block height, so you will be running the latest LWMA-2 by block 3. * `const uint32_t ZAWY_DIFFICULTY_BLOCK_INDEX = 0;`\
* `const uint32_t LWMA_2_DIFFICULTY_BLOCK_INDEX = 1;`\
* `const uint32_t LWMA_2_DIFFICULTY_BLOCK_INDEX = 2;`\
* `const uint32_t LWMA_2_DIFFICULTY_BLOCK_INDEX = 3;`\
**`const unsigned EMISSION_SPEED_FACTOR = 25;`**
This value defines how fast the maximum supply will be emitted. A smaller value means the supply will be emitted faster, and a higher values means it will take longer for the supply to be released. You can again use the website [linked earlier](https://cryptonotestarter.org/tools.html) to experiment with different values for the emission and how they will affect how long it takes for the supply to be distributed. If we wanted a fast emission, we could set this to a value like 21. * `const unsigned EMISSION_SPEED_FACTOR = 21;`
**`const size_t CRYPTONOTE_DISPLAY_DECIMAL_POINT = 2;`**
This value defines how many numbers there are after the decimal point in your currency. In Kryptokrona, this value is 2, so we have amounts like 10.23 XKR. If we set this to 6, we would have an amount like 10.234567 XKR instead. Remember, as previously mentioned, this affects your money supply and other parameters which depend upon atomic units. * `const size_t CRYPTONOTE_DISPLAY_DECIMAL_POINT = 6;`
**`const uint64_t MINIMUM_FEE = UINT64_C(10);`**
This value defines what the minimum fee a user must spend to send a transaction is. Note this doesn't apply to fusion transactions. A lower value allows cheaper transactions, but can mean your network can be spammed by lots of small transactions. A happy medium is generally desired, though you could optionally raise this at a later date. This value is defined again in *atomic units*, so multiply your desired minimum fee by 10 \* the number of numbers after the decimal point in your coin. * `const uint64_t MINIMUM_FEE = UINT64_C(1000);`
**`const uint64_t MINIMUM_MIXIN_V1 = 0;`**
This section will cover all of these, because they are all related: ``` const uint64_t MINIMUM_MIXIN_V1 = 0; const uint64_t MAXIMUM_MIXIN_V1 = 100; const uint64_t MINIMUM_MIXIN_V2 = 7; const uint64_t MAXIMUM_MIXIN_V2 = 7; const uint32_t MIXIN_LIMITS_V1_HEIGHT = 440000; const uint32_t MIXIN_LIMITS_V2_HEIGHT = 620000; const uint64_t DEFAULT_MIXIN = MINIMUM_MIXIN_V2; ``` These set the mixin values that are allowed on the network, and at what height they are applied. If you want a private coin from the get-go, I would suggest setting MIXIN\_LIMITS\_V1\_HEIGHT to 0, and MIXIN\_LIMITS\_V2\_HEIGHT to 1. Then, set the MINIMUM\_MIXIN\_V1/V2 and MAXIMUM\_MIXIN\_V1/V2 values as appropriate. Don't set a value that is *too* high, otherwise your network will have difficulty processing transactions. You shouldn't set the minimum anymore than 100, and sane values would be somewhere in the 0 - 30 range. `DEFAULT_MIXIN` is used to set the mixin value used in zedwallet, so set it to a sane value. Make sure your minimum is less than or equal to your maximum! ``` const uint64_t MINIMUM_MIXIN_V1 = 0; const uint64_t MAXIMUM_MIXIN_V1 = 100; const uint64_t MINIMUM_MIXIN_V2 = 7; const uint64_t MAXIMUM_MIXIN_V2 = 7; const uint32_t MIXIN_LIMITS_V1_HEIGHT = 0; const uint32_t MIXIN_LIMITS_V2_HEIGHT = 1; const uint64_t DEFAULT_MIXIN = MINIMUM_MIXIN_V2; ```
**`const uint64_t DEFAULT_DUST_THRESHOLD = UINT64_C(10);`**
This section will cover all of these, because they are all related: ``` const uint64_t DEFAULT_DUST_THRESHOLD = UINT64_C(10); const uint64_t DEFAULT_DUST_THRESHOLD_V2 = UINT64_C(0); const uint32_t DUST_THRESHOLD_V2_HEIGHT = MIXIN_LIMITS_V2_HEIGHT; ``` The dust threshold determines the smallest amount that can be sent in a transaction, and can lead to lots of tiny amounts accumulating in your wallet which cannot be sent. Setting the dust threshold to zero prevents this, but has a side effect of making transactions slightly bigger. I suggest setting DUST\_THRESHOLD\_V2\_HEIGHT to 0, to make small amounts always spendable. * `const uint32_t DUST_THRESHOLD_V2_HEIGHT = 0;`
**`const uint32_t UPGRADE_HEIGHT_V4 = 350000;`**
This value determines when the mining algorithm will transition to Original CryptoNight, also known as CN v0, to CryptoNight Lite v1, also known as CryptoNight Lite v7. Original CN currently allows ASICs on the network, so we suggest you set this upgrade height to 3, to near instantly switch to the ASIC resistant CryptoNight Lite v1. However, if you would prefer to stay on original CryptoNight, you can either find where this variable is used and patch it out, or, you can set the upgrade height to `std::numeric_limits
**`const uint64_t FORK_HEIGHTS[] =`**
This variable is used by the `status` command in zedwallet and Kryptokrona to notify users when a fork is upcoming, or their software is outdated. We suggest you set up some regular forks ahead of time, if you then need to update the software this will let users know when to expect this. If you wish to not pre-prepare any forks, you can empty the list. This will set the status command to notify of a fork at 100k and 300k blocks. * ``` const uint64_t FORK_HEIGHTS[] = { 100000, 300000 }; ```
**`const uint8_t CURRENT_FORK_INDEX = FORK_HEIGHTS_SIZE == 0 ? 0 : 3;`**
This value relates to the previous FORK\_HEIGHTS array. It determines which fork heights the software supports. (This value is zero-indexed). For example, if our `FORK_HEIGHTS = {100, 200, 300}` and `CURRENT_FORK_INDEX = 1` then the software will support the fork at FORK\_HEIGHTS\[1] - which is the fork at 200 blocks. We have a ternary to check FORK\_HEIGHTS\_SIZE so if you wish to empty the FORK\_HEIGHTS array, you don't need to set a CURRENT\_FORK\_INDEX. * `const uint8_t CURRENT_FORK_INDEX = FORK_HEIGHTS_SIZE == 0 ? 0 : 1;`
**`const char CRYPTONOTE_NAME[] = "Kryptokrona";`**
This is an obvious one. It's the name of your coin! * `const char CRYPTONOTE_NAME[] = "SuperCoolCoin";`
**`const int P2P_DEFAULT_PORT` and `const int RPC_DEFAULT_PORT`** These values define the ports that are used by the daemon to communicate. There is no real issue with using the same values as the Kryptokrona software, but if you are running both a Kryptokrona daemon and your own daemon, you would have to change the port one uses, as they will both need control over the port. Ports can be in the range of 0 - 65535, however using ports in the 0 - 1023 range is not recommended, as on unix systems a program will require administrative permissions to use these ports. * `const int P2P_DEFAULT_PORT = 10101;` * `const int RPC_DEFAULT_PORT = 10102;`
**`const static boost::uuids::uuid CRYPTONOTE_NETWORK =`** This value sets the 'Network ID' of your coin. This ensures your network will not respond to network connections from other coins, such as Kryptokrona. This value is using hex values, which should be in the form 0x?? where `?` is a valid hex value (0-9, a-f). * ``` const static boost::uuids::uuid CRYPTONOTE_NETWORK = { { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x00 } }; ```
**`const char* const SEED_NODES[] = {`**
This variable defines the seed nodes daemons will connect to on the very first launch, before they are aware of any peers. You will need to run these on different servers, to bootstrap other nodes. Once your coin is established, it might be a good idea to ask other trusted community members to host some seed nodes, to help decentralize your coin. * ``` const char* const SEED_NODES[] = { "111.111.111.111:11897", "222.222.222.222:11897", }; ```
### CryptoNoteCheckpoints.h A nice quick job, we need to remove all the checkpoints in `src/CryptoNoteCheckpoints.h` Checkpoints are used to verify that whilst syncing, you are on the right path, and not wasting your time syncing blocks from an incorrect daemon. It does this by matching a block hash to a block height. This is all grand, however if you are creating a new chain, you will of course have new hashes for your blocks! To fix it, just set `const std::initializer_list
**`const std::string addressPrefix = "XKR";`**
This value is used to check inputted addresses are correct. This value corresponds to the value you chose for your address prefix earlier, in `const uint64_t CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX =` * `const std::string addressPrefix = "aPPLE";`
**`const std::string ticker = "XKR";`**
This refers to the 'short name' your coin has, which is often used as a ticker on exchanges. For example, in Kryptokrona this is XKR, in Monero this is XMR, and in Bitcoin this is BTC. * `const std::string ticker = "APPLE";`
**`const std::string daemonName = "Kryptokrona";`**
This variable determines what the name of your daemon is. We'll talk about changing the names of the executables generated in the `CmakeLists.txt` section. We'll skip mentioning `walletName`, and `walletdName` as these both follow the same format. * `const std::string daemonName = "AppleCoind";`
**`const std::string contactLink = "http://chat.kryptokrona.se";`**
This value is used to let the user know where they can get support if their wallet gets stuck whilst syncing. In our case, this is the Kryptokrona discord. Maybe you have a forum or an IRC chat instead? * `const std::string contactLink = "https://applecoin.com/livechat"`
**`const long unsigned int standardAddressLength = 99;`** This value is used to verify inputted addresses are correct. You can easily get this value by compiling, generating an address with zedwallet, and checking how long it is. * `const long unsigned int addressLength = 100;`
**`const long unsigned int integratedAddressLength = 236;`**
This value is used to verify inputted addresses are correct. An integrated address is an address which also contains an embedded payment ID, to alleviate users from having to remember to supply one with the transaction. You can easily get this value by compiling, generating an address with zedwallet, then using the `make_integrated_address` command, and checking how long it is. You can use your own address with this command, and any payment ID. If you don't know how to generate a payment ID, here's a random one for you to use. `8eba031ca60bf9b9f680309819bddf071e619c53ff71766e48e365812e229452` * `const long unsigned int integratedAddressLength = 237;`
**`const uint64_t defaultMixin = CryptoNote::parameters::DEFAULT_MIXIN;`**
This sets the mixin value to be used with transactions. Make sure this is in the bounds you set earlier, with `MINIMUM_MIXIN_V1/V2` and `MAXIMUM_MIXIN_V1/V2`. * `const uint64_t defaultMixin = 7;`
**`const uint64_t defaultFee = CryptoNote::parameters::MINIMUM_FEE`**
If you want to set a higher default fee, perhaps to make transactions go through quicker, you can do that here. As usual, this is in *atomic units*. You may also wish to change `const uint64_t minimumFee = CryptoNote::parameters::MINIMUM_FEE;` to prevent users from sending a lower fee than desired. Remember this limit is only enforced by zedwallet, and the user can change the limit and recompile, or use a different wallet program. If you want to enforce higher fees across the network, change the value of `CryptoNote::parameters::MINIMUM_FEE` in `CryptoNoteConfig.h`. * `const uint64_t defaultFee = 100;`
**`const bool mixinZeroDisabled = true;`**
Is a mixin of zero allowed on the network? If at some point a mixin of zero will be disabled, but that point is at a later fork, still set this to `true`. If you set this to true, you can change the value of ``` const uint64_t mixinZeroDisabledHeight = CryptoNote::parameters::MIXIN_LIMITS_V2_HEIGHT; ``` To determine what block height a mixin of zero gets disabled. In Kryptokrona's case, this was disabled at block 620k, but being a new network, you have the advantage of being able to disable a mixin of zero much earlier, or even from the launch of your network. Again, this is only a client-side limitation. Ensure you have set your mixin limits in `CryptoNoteConfig.h` so that the network will enforce the mixin limits. Any ideas you always want to happen, need to be done at the network level, else custom daemons/wallets etc. can be written to avoid those ideas/limits. If you want to allow zero mixins, then `mixinZeroDisabledHeight` does nothing. * ``` const bool mixinZeroDisabled = true; const uint64_t mixinZeroDisabledHeight = 0; ```
### Setup Ok, so you've finished tweaking all the configs, and now you're ready to go! To start with, you will need to compile your code. See the compiling section below. Make sure you've got the IPs of your seed nodes filled in in the config, 3 daemons need to be connected to the network for your coin to work. Once you've compiled the code on all your machines, you can start up your daemon. If you are unable to connect to the seed nodes, you will see something like `Failed to connect to seed nodes` in your daemon output. Ensure your firewalls are not preventing the daemon connection, you may need to open the p2p and RPC ports for the daemon, which by default are 11898 and 11897. If your daemons are now talking to each other, you can start mining, and launch your blockchain! You can use the solo mining `miner` executable for this. From a command prompt or terminal, launch the miner like so: `miner --threads 1 --log-level 3 --address
As a first time user, tap "Create new account" and follow the instructions. If you have had an account before, you may choose the "Restore account" option instead.
If you created a new account, make sure to save the mnemonic seed at the step shown in the picture below:
Your Hugin account is both your messaging account and a wallet for XKR. If you lose your device, the only way to restore your XKR balance is by restoring your account on another device with the mnemonic seed. **Store it somewhere safe!**
## **Funding your account**
After following the instructions for creating/restoring your account, you should be greeted by your profile page:
Your profile page contains your contact details and your wallet balance. If you want to give your contact details to someone, you can click the "Copy" button (see picture above) and send your address to someone. You may also click the background to reveal your QR-code (see picture below) that can be scanned by someone else in order to quickly add you.
The XKR wallet in Hugin is used both as a small stake while sending messages, and as a way to transfer funds privately.
If you don't have any XKR, you can only receive messages, so make sure your account is always funded. You can get funds either by [mining](https://kryptokrona.org/en/mining), [buying](broken://pages/jqxT9vu7KmdNq8hCkhL0), or using the [faucet](https://kryptokrona.org/en/faucet). If you have 0 balance, you should be able to see the "Top up" button on your profile. Click it to go directly to the faucet, which will give you 5 XKR to start out with.
Make sure your payment address is added to the address-field, solve the captcha and then hit 'Claim'. That should give you 5 free XKR. After \~90 seconds your funds is available in your account (go to your profile page to see your current balance).
As you can see in the picture above, the account has now been funded with 5 XKR and is now ready to be used!
## Adding contacts
To add a new chat contact, go to the private message page (the 💬 icon) and click the Add contact button in the top right corner (pictured below).
Then you may either paste your contacts Address and message key into the form, or scan your friends QR code - and then enter a nickname for your contact.
Tap 'Continue' and the you will find yourself in an open chat with your new contact! Simply type a message and hit 'Send' to send them a message!
## Sending payments
In addition to sending messages, you can also send payments to your contacts! Do this by going to the payment screen (the wallet icon). Then pick the contact you want to send funds to at the screen in the picture below:
Now just enter the amount you want to send, or pick "Send all" if you want to send your entire balance. Then confirm the transfer and it should be on it's way! 💸
## Using boards
Boards are public message boards where you can communicate with strangers and friends alike. Unlike with private messages in Hugin, boards messages are *not* encrypted!
To use boards in Hugin Mobile, click the double 💬 icon in the menu and you will se a screen that looks a little bit like this:
This is the Home board and it collects message from all other boards. You may click a post to browse the board that it was posted in. You can also switch board, and add or remove subscriptions to boards by clicking the active board title (the blue "Home" in the top right corner in the picture above).
### Add/remove board subscriptions
The picture above is the My Boards screen, you can tap 'Edit' to remove subscriptions to boards, or add a new board subscription by typing it's name in the 'Add board'-field directly under the title and then hitting enter on the keyboard.
To create a brand new board, you do the exact same thing as above.
In the picture above you can see how I have created a new board called 'My Cool Community' which I can then use to talk to my cool friends!
## That's all folks!
If you're having trouble or want to know more, you can come ask us anything in our [Discord server](https://chat.kryptokrona.se). Welcome!
# How to run a Hugin Node
This page will help you get started with starting a Hugin Node.
### What are Hugin Nodes?
Hugin Nodes are the cornerstone of the Hugin Messenger message distribution system. When two users who are online try to send a message to one another, the message will be sent through a P2P tunnel, powered by [HyperSwarm](https://github.com/holepunchto/hyperswarm).
However, when the recipient of a message is not online, the message is instead sent to the decentralized Hugin Node network. If the user has a registered a mobile device with the Hugin Master Nodes, the message will first be sent as a push notification to it's device. Additionally, the Hugin Nodes will store encrypted messages for 25h so they can be read once the user is back online. Messages sent to the nodes are always end-to-end encrypted.
To reward Hugin Node operators, each message sent from a client to the node network will also have a small proof-of-work segment appended to the message, that the receiving Hugin Node can send to the XKR mining network in order to garner a small XKR reward for each message relayed. This also provides the network with spam protection.
### How to install the Hugin Node software
1. Install nodejs `wget https://kryptokrona.se/downloads/xkr-rpi3.zip`\ \ `unzip kryptokrona-rpi-3b.zip`
\ ***For Raspberry Pi 4B:*** `wget https://kryptokrona.se/downloads/xkr-rpi-4b.zip`\ \ `unzip kryptokrona-rpi-4b.zip` When you have unzipped the files, enter the directory where the kryptokrona binary was unzipped to and run the following to start your node: `./kryptokrona --enable-cors=* --enable-blockexplorer --rpc-bind-ip=0.0.0.0 --rpc-bind-port=11898` # How to configure the node? Run kryptokronad with arg `--help` will print all options. Kryptokrona can start with these options by command line args, or use `-c` followed a json file for configuration. The option in config file will unwrap the front `--`, for example: ```json // the config file { "db-max-open-files": 125, "db-read-buffer-size": 128, "db-threads": 4, "db-write-buffer-size": 256 } ``` If you want to check the default options, use `--dump-config`. # Node bootstrap If you've just set up your node, it's a good idea to use our bootstrap to make the initial sync a lot faster! Starting in your home folder (cd \~), the first order of business is to download our bootstrap with this command: ``` wget https://xkrbootstrap.vm-app.cloud.cbh.kth.se/latest.7z ``` After it has downloaded, use this command to extract the file: ``` // apt install 7z (if you don't have it installed) 7z x latest.7z ``` Then just start the node, which you can read up on how to do in the other guides! Thanks for hosting a node, and don't forget to add it to
XMRig mining kryptokrona on Windows
Config file properly placed inside the XMRig-folder.
If everything went right, it should look something like this!
The Flight Sheets screen
Wallet creation screen
CPU Mining config with XMRig (new)
A good looking NVIDIA setup
A fully configured XMRig NVIDIA
A fully configured AMD miner
A miner running CPU + NVIDIA + AMD mining would look like this.
Start flight sheet from here
Active hashrate on XKR