Facet operates as a unique scaling solution distinct from traditional Layer 2 (L2) rollups like Optimistic and ZK rollups. Unlike these rollups, which batch transactions off-chain and later submit them to Ethereum, Facet processes transactions directly on Ethereum's mainnet. This ensures immediate finality and 100% uptime, directly linking its reliability to Ethereum’s uptime.

Key differences include:

1. Immediate Finality and Uptime: Traditional rollups can experience delays due to complex fraud or validity proofs and dependencies on centralized sequencers. In contrast, Facet leverages Ethereum's existing consensus mechanism for transaction ordering and security - Facet transactions achieve finality in direct sync with Ethereum’s finality - ensuring faster processing and uninterrupted service. As long as Ethereum is operational, Facet is fully functional. We call this mirrored reliability which cannot be matched by parallel or separate blockchains.
2. Decentralization and Censorship Resistance: Traditional Layer 2 solutions often rely on centralized sequencers, which can introduce points of failure and censorship. Facet transactions are sent directly by users to Ethereum, bypassing the need for a centralized sequencer and ensuring open participation and robust resistance to censorship. This enhances the security and neutrality of the network.
3. Elimination of Bridges: Layer 2s have a strict dependency on their L1 bridge smart contract and other related smart contracts. Typically these contracts are upgradeable by small groups of people with little notice. Facet, by contrast, has no privileged official bridge, and avoids these trust assumptions. Facet users interact directly with Ethereum, avoiding the need to trust Layer 2 operators who manage enshrined bridges. This approach reduces complexity and enhances security, as there is no dependency on bridge mechanisms that can be points of failure or targets for attacks.
4. Autonomy and Security: Traditional Layer 2 solutions are often controlled and operated by centralized entities, which can lead to potential downtime or even permanent shutdowns. Facet, however, is not controlled by any single entity, making it immune to such risks. In the event of a Layer 2 shutdown, users may face significant losses, especially for assets held in smart contracts or created on the L2. Facet’s direct integration with Ethereum ensures that if Ethereum is up, Facet is up, providing consistent and dependable performance.

These features make Facet a robust and secure alternative to traditional L2 scaling solutions. A more detailed comparison between Facet and traditional L2 solutions is best illustrated by reviewing the common blockchain criteria below

Facet guarantees 100% uptime by directly using Ethereum's network for transaction initiation and finality. Anyone can send Facet transactions directly to Ethereum with no intermediaries. Since every Facet transaction is inherently an Ethereum transaction, Facet remains fully functional as long as Ethereum is operational.

Facet also has no privileged party responsible for broadcasting the state of the protocol, and whose ceasing to function could limit access to Facet state. Rather Facet state is equally available to anyone through the open source Facet VM software.

Moreover, even if every Facet VM in the world were to go down, any single party could still compute the state on their own using the VM. This ensures that the system's integrity and functionality can be maintained independently, providing an additional layer of reliability. This direct dependence on Ethereum’s robust and widely trusted network, coupled with the ability for independent state computation, ensures continuous service availability with no downtimes associated with Facet's operations.

In short - Facet runs on Ethscriptions.

The original intent of Ethscriptions was for you to transmit “digital artifacts” (images, videos, text, etc) through the calldata field.

Facet turns this idea on its head by using the calldata field not to represent a “digital artifact” but rather to represent a command to a smart contract—calldata’s original intended use case! The Facet twist is that it uses the calldata field to represent a command to a contract in a different virtual machine.

Facet leverages the Ethscriptions protocol to facilitate its unique approach to (1) transaction processing and (2) off-chain computation.

1. Facet transactions are encoded directly on Ethereum as Ethscriptions, including specific instructions and data essential to execute Facet smart contract logic. The use of Ethscriptions ensures all transaction data is immutable, transparent, and accessible for future reference.

2. These Ethscriptions are indexed and off-loaded to the Facet Virtual Machine (FVM), which interprets the encoded data, executes the corresponding Facet smart contract logic and manages state persistence off-chain. Because the FacetVM execution is deterministic, the same Ethscription input will always produce the same Facet state, guaranteeing state changes can be independently verified by anyone running the FacetVM.

While traditional Layer 2 solutions deploy centralized sequencers for transaction ordering and batching (at the expense of decentralization), Facet leverages Ethereum's existing consensus mechanism to ensure all transactions are transparently ordered and finalized into blocks by Ethereum’s validator network. Thus, no single party is in a position to exploit MEV opportunities (as is the case with centralized sequencers). Moreover, Facet’s off-chain transaction processing is only used for deterministic tasks to enhance scalability without compromising security. This approach ensures that Facet’s operations are neutral, fair, and reliable, embodying the core principles of blockchain technology.

Facet's security model is based on the innate, objective reality that is derived from (1) immutable transaction history and (2) deterministic computation. FacetVMs don’t create that objective reality - they merely report it.

If two people agree on the state of Ethereum, they will also agree on the state of Facet.

1. On-Chain Transactions: Every Facet transaction is an Ethereum transaction that is sequenced and finalized by Ethereum’s consensus mechanism. This means that the immutable integrity of the transaction history is maintained, irrespective of the number of FacetVMs computing the state. Thus, the foundational data (inputs) that Facet operates on is always secure and decentralized.
2. Deterministic State Computation: The key to Facet’s security lies in deterministic state computation. FacetVMs operate deterministically, meaning that given the same inputs (i.e. transactions), every FacetVM will always produce the same output (i.e. state). This deterministic nature ensures that the state is an objective reality, independent of how many FacetVMs are computing it.

While having multiple FacetVMs might create a perception of increased security because they would independently compute and align on the same state, the actual security of Facet does not rely on the number of FacetVMs. This contrasts with proof-of-stake operating models, where more validators equate to greater security. With Facet, anyone can independently verify the correctness of the state by running the FacetVM themselves.

Even if you do act on incorrect Facet state data it is unlikely to cost you money because the transactions you send will be conditional. For example, if someone reports to you that an asset you hold is worth 10x what it’s actually worth, and you decide to sell on the basis of that knowledge, your transaction will include a slippage value that will cause the transaction to revert.

The concept of an "honest operator" is central to Facet's security model. As long as there is at least one honest operator running a FacetVM, it is difficult for any malicious party to alter the state without being detected. This honest operator can independently verify the state and call out any discrepancies, maintaining the integrity of the system.

And of course - you yourself can run the FacetVM and be that “honest operator.”

The potential pruning of calldata and blob data, as proposed in certain Ethereum Improvement Proposals (EIPs), poses considerations for the Ethereum ecosystem, including Facet and Layer 2 solutions. However, it’s important to clarify that these prunings do not threaten Facet's operation.

This is because of two factors:

1. Even if the Ethereum protocol allows nodes to prune calldata and blob data, this data remains immutable and cannot be forged. As long as one person has this historical data it can be verified as authentic and used by everyone else.

2. There is great demand for historical Ethereum data that extends far beyond Facet. Layer 2s obviously have an interest in validating their history, but even more people are interested in validating the history of Ethereum itself, and you can’t do this without the data Facet needs to operate.

Even today, most people, operating according to this principle, get their Ethereum data from a third party provider instead of a node they themselves operate. This is a secure practice today because all such data can be verified, and it will remain a secure practice even when data is pruned.

Pruning would only become an issue for Facet if (2) was no longer true, but such a massive loss of Ethereum historical data would indicate a much larger systemic failure beyond just impacting Facet.

Rubidity is a high-level, object-oriented programming language designed for creating Facet smart contracts. Rubidity retains the structure of Solidity but introduces Ruby-like syntax and concepts, with the goal of making Facet smart contract development intuitive for developers familiar with both languages.