Build the next
generation of apps

Netcore is revolutionizing app development with scalable, low latency, decentralized network infrastructure.

How data was always meant to be shared

We're building the original peer-to-peer vision of the web. By developing a network infrastructure that removes the need for intermediaries, we minimize cost barriers for app development and ensure fast, secure, and censorship-resistant applications for end users.

The Netcore Vision

bool verify_given_keys_can_unlock(struct spend_utxo* su) {
    char hl[DEFAULT_HASH_BUCKET_SIZE];
    char * hash_list = hl;
    int32_t hash_list_size = DEFAULT_HASH_BUCKET_SIZE;
    int32_t num_hashes = 0;
    bool hashed = hash_keys(&hash_list, &hash_list_size, &num_hashes, su);
    if (!hashed) 
    {
        free_key_hashes(hash_list, hash_list_size);
        return false;
    }

    char sb[DEFAULT_CSTACK_SIZE];
    char stb[CSTACK_STRUCT_SIZE];
    char * stack_bucket = sb;
    char * struct_bucket = stb;
    CSTACK s = create_stack_from_bucket(struct_bucket, stack_bucket, DEFAULT_CSTACK_SIZE);
    uint32_t i = 0;
    while (i < su->ls_len)
    {
        switch (su->locking_script[i])
        {
        case 'O':
            i++;
            push_stack(
                s, 
                is_hash_in_list(su->locking_script + i, hash_list, num_hashes)
            );
            i += NC_HASH_LEN;
            break;

        case '@':
            i++;
            push_stack(
                s,
                has_time_passed(*(time_t *) (su->locking_script + i))
            );
            i += at_BYTES;
            break;

        case '|':
        case '&':
            if (stack_content_count(s) < 2) 
            {
                free_key_hashes(hash_list, hash_list_size);
                free_stack(s);
                return false;
            }
            bool a = pop_stack(s);
            bool b = pop_stack(s);
            push_stack(
                s,
                su->locking_script[i] == '|'
                    ? (a || b)
                    : (a && b)
            );
            i++;
            break;

        default:
            return false;
        }
    }
    bool res = false;
    if (stack_content_count(s) == 1 && i == su->ls_len) 
    {
        res = pop_stack(s);
    }
    free_stack(s);
    free_key_hashes(hash_list, hash_list_size);
    return res;
}

The power of a decentralized network

Real-time Responsive Blockchain

Our unique, real-time responsive blockchain allows the Netcore network to power apps that require real-time updates, such as chat apps or social media platforms. Our novel consensus protocol enables some of the best performance and robustness.

Secure Data

By leveraging blockchain technology in our novel architecture, personal data remains secure. Our blockchain serves as a directory for finding peers, while data is transmitted through direct peer-to-peer connections that are encrypted end-to-end.

Censorship Resistant Network

With our decentralized network, censorship becomes impossible. Netcore promotes equal access to information, preventing any central body from restricting app availability.

For Developers

Join a growing community building the next generation of decentralized apps.

Learn More

For Node Operators

Learn about our network infrastructure and contribute to the decentralization of the web.