HADI W3B

Accelerating Development: A Practical Guide to Building on Fogo
In the modern development landscape, agility is everything. Developers want to focus on writing business logic, not managing complex infrastructure sprawl. This is where Fogo steps in.
Fogo is designed to streamline the path from code to production. Whether you are deploying a monolithic application, microservices, or serverless functions, Fogo provides the abstraction layer needed to build fast and ship faster.
Based on the official Fogo documentation, this guide walks you through the foundational steps of building applications on the platform, moving from initial setup to your first successful deployment.
1. Prerequisites and Setup
Before you can start building, you need to prepare your environment. Fogo relies on a combination of a web dashboard and a powerful Command Line Interface (CLI) to manage your projects.
Step 1: Create an Account
Ensure you have a registered account at Fogo.io and have set up any necessary organization or billing details.
Step 2: Install the Fogo CLI
The CLI is your primary bridge to the Fogo platform during development. It allows you to initialize projects, run local emulators, and push deployments from your terminal.
(Hypothetical installation command)
# Using npm
npm install -g fogo-cli

# Using brew/curl (alternative)
brew install fogo/tap/fogo
Step 3: Authenticate
Once installed, link your local machine to your Fogo account:
fogo login

This command will open your browser to authenticate your session.
2. Core Concepts: The Fogo Architecture
Understanding how Fogo organizes your work is crucial for efficient building. Fogo generally uses a hierarchical structure to manage resources.
Organization: The top-level entity, usually representing your company or team.Project: A logical container for a specific application (e.g., "Customer Portal" or "Inventory API"). Projects often map to a single Git repository.Services (or Functions): The individual deployable units within a project. A project might contain a front-end React service and a back-end Node.js API service.Environments: Distinct stages for your deployment pipeline (e.g., Development, Staging, Production). Fogo allows you to promote code across these environments easily.
3. The Build Workflow: Creating Your First Service
Building on Fogo typically follows a "Code-Config-Deploy" loop. Let’s look at how to create a simple backend service.
A. Initialize the Project
Navigate to your project folder and initialize Fogo. This typically creates a configuration file in your root directory.
mkdir my-fogo-app && cd my-fogo-app
The initialization wizard will prompt you for the project name and preferred region.
B. Write the Code
Fogo is designed to be language-agnostic, supporting popular runtimes like Node.js, Python, Go, and Ruby.
Let’s create a simple "Hello World" API endpoint using Node.js. Create an index.js file:
// index.js
const http = require('http');

const server = http.createServer((req, res) => {
res.statusCode = 200;
res.setHeader('Content-Type', 'text/plain');
res.end('Hello from Fogo Platform!\n');
});

const port = process.env.PORT || 3000;
server.listen(port, () => {
console.log(`Server running on port ${port}`);
});
Note: It is vital to ensure your application listens on the port assigned by Fogo's environment variables (usually process.env.PORT), rather than hardcoding a port like 3000.
C. Configuration (The fogo.yaml file)
How does Fogo know how to run your code? You need a configuration file to declare your runtime, entry point, and resource requirements.
Create a fogo.yaml (or fogo.json) file in your root directory:
version: 2
name: my-api-service
runtime: nodejs18
build:
command: npm install
run:
command: node index.js
port: 3000 # The internal port your app listens on
scaling:
min_instances: 1
max_instances: 5

This file tells Fogo: "Use Node 18, run npm install to build it, start it using node index.js, and expect traffic internally on port 3000."
4. Testing and Deployment
Local Development
Before pushing to the cloud, test your service locally using the Fogo CLI’s emulator. This ensures your configuration is correct.
This will start your application locally in an environment that mimics the Fogo production runtime, exposing it at a localhost address.
Deploying to the Cloud
Once satisfied with the local build, deploying is a single command. Fogo will package your code, upload it, build the necessary containers or functions, and route traffic to them.
fogo deploy

The CLI will stream build logs to your terminal. Upon completion, it will return a live, publicly accessible URL for your new service (e.g., https://my-api-service-xyz.fogo.app).
5. Next Steps: Managing Your Build
Building the app is just the beginning. The documentation highlights several key features for managing applications in production:
Environment Variables: Never hardcode secrets. Use the Fogo dashboard or fogo env set DATABASE_URL=... to securely inject API keys and database strings into your runtime environment.CI/CD Integration: While manual deployment is great for testing, Fogo is designed to integrate with Git providers (GitHub, GitLab). You can configure Fogo to automatically deploy every time you push to your main branch.Observability: Access real-time application logs and performance metrics directly from the Fogo dashboard or via the CLI using fogo logs tail.
Conclusion
Building on Fogo shifts the developer's focus away from infrastructure plumbing—like configuring Kubernetes or managing load balancers—and back to creating value through code. By following the structured workflow of initializing, configuring, and deploying via the CLI, teams can significantly reduce their time-to-market.
For more advanced configurations, including custom domains, VPC peering, and persistent storage options, refer to the advanced sections of the official Fogo documentation.
@Fogo Official #fogo $FOGO

Introduction
@Fogo Official is a high performance Layer 1 blockchain that builds on the design principles of Solana while introducing architectural innovations focused on reducing latency and improving validator efficiency. The core idea behind Fogo architecture is simple but powerful. Instead of only optimizing consensus logic at the software level, Fogo optimizes the physical and operational layers of the network to achieve faster block settlement and higher throughput.
This article explores the architecture of $FOGO in detail, including its consensus model, validator zones, Firedancer based client design, and performance optimization mechanisms.
Core Execution Layer and SVM Compatibility
Fogo implements the Solana Virtual Machine SVM as its execution environment. This ensures that smart contracts, tools, and infrastructure built for Solana can operate on Fogo with minimal modification. Developers can migrate applications while benefiting from improved performance characteristics.
Like $SOL , Fogo follows a rotating leader model. Validators are selected to propose blocks based on a deterministic stake weighted schedule computed at epoch boundaries. Validators with more delegated stake are assigned more leadership slots. This design aligns economic incentives with network security and participation.
During a leader’s slot, the validator performs several tasks. It receives transactions through a high performance networking pipeline, verifies signatures, executes transactions against the current state, and packages results into entries linked by Proof of History. These entries are then distributed across the network for validation and voting.
Consensus Mechanism
Fogo uses Tower BFT as its consensus algorithm, inherited from Solana’s design. Validators vote on blocks and apply exponentially increasing lockouts to their votes. This creates a strong economic disincentive for switching forks and promotes chain stability.
A block becomes confirmed when more than sixty six percent of total active stake votes for it. Finalization occurs after sufficient additional confirmations, providing strong guarantees against reorganization. The heaviest fork choice rule ensures that the chain with the most accumulated stake weight becomes canonical.
While the consensus logic remains compatible with Solana, Fogo introduces architectural enhancements that improve real world performance.
Validator Zones
One of the most innovative architectural features of #Fogo is the validator zone system. Instead of having all validators globally participate in consensus at all times, Fogo divides validators into distinct zones. Only one zone is active during each epoch.
Zone definitions and validator assignments are stored on chain and managed transparently. At each epoch boundary, a deterministic algorithm selects the active zone. Validators within the selected zone participate in block production and voting, while validators in other zones remain synchronized but inactive in consensus.
Fogo supports multiple zone selection strategies. Epoch based rotation allows zones to activate sequentially. Follow the sun rotation activates zones based on coordinated universal time, shifting consensus participation across geographic regions during peak usage hours.
This architecture reduces the physical distance between validators participating in consensus. By limiting the active quorum to a more localized subset, Fogo reduces wide area network latency on the critical path. At the same time, a minimum stake threshold ensures that any active zone maintains sufficient security.
Firedancer Based Validator Client
Fogo leverages the Firedancer validator client for high performance execution. The production implementation known as Frankendancer combines Firedancer networking and block production components with Solana’s Agave logic.
The Firedancer architecture is based on independent functional units called tiles. Each tile runs as a separate process pinned to a dedicated CPU core. Instead of sharing CPU resources through context switching, each tile continuously processes its specific workload, maximizing hardware efficiency.
Key components in the pipeline include
Network tile for packet ingestion using kernel bypass techniques
QUIC processing tile for transaction stream handling
Signature verification tiles for parallel cryptographic validation
Deduplication tile to eliminate duplicate transactions
Execution tile for updating account state
Proof of History tile for maintaining the cryptographic clock
Shred encoding and storage tiles for block propagation and persistence
Tiles communicate using shared memory queues, enabling zero copy data flow. Transactions move through the pipeline without repeated serialization or memory copying. This reduces latency and memory bandwidth usage while improving throughput.
The result is predictable performance with reduced jitter, improved cache utilization, and efficient scaling across multiple CPU cores.
Leader Schedule and Epoch Management
Leader schedules are computed at epoch boundaries using stake weighted randomness derived from chain state. This deterministic yet fair rotation ensures predictable block production while preventing manipulation.
At the start of each epoch, stake filtering occurs to determine which validators are eligible for participation based on the active zone. Only stake from validators within the selected zone contributes to supermajority thresholds and leader scheduling for that epoch.
This controlled participation model ensures that consensus remains secure while reducing geographic dispersion in the active validator set.
Fee Model and Economic Layer
Fogo mirrors Solana’s fee structure to maintain familiarity for developers and users. A basic transaction carries a base fee measured in lamports. Half of this base fee is burned and half is paid to the processing validator. Priority fees during congestion are paid entirely to the block producer.
The architecture also includes a rent mechanism that charges accounts for storage usage unless they maintain a rent exempt minimum balance. This prevents state growth from becoming unsustainable.
The network operates with a fixed annual inflation rate. Newly minted tokens are distributed to validators and delegators based on vote credits earned during each epoch. This ties economic rewards directly to active and correct participation in consensus.
Sessions and User Experience Layer
Fogo architecture extends beyond consensus and validation into user experience. The Sessions standard allows users to authorize applications through a single signed intent. This creates time limited scoped permissions that reduce signature fatigue.
Applications can execute transactions within session limits without requiring repeated wallet approvals. Optional fee sponsorship mechanisms enable gasless interactions while preserving self custody and security guarantees.
This design allows decentralized applications to offer experiences comparable to traditional Web2 platforms without sacrificing decentralization principles.
Conclusion
Fogo architecture represents a holistic redesign of blockchain performance optimization. It maintains compatibility with Solana’s execution and consensus layers while introducing validator zones and a high performance Firedancer based client to address real world latency constraints.
By reducing geographic dispersion in consensus, standardizing validator performance, and optimizing hardware utilization, Fogo achieves faster confirmations and improved throughput. Its architecture demonstrates that meaningful blockchain performance gains come not only from better algorithms but from engineering the entire physical and operational stack around real world conditions.
#ALPHA🔥 $IP

Of course. Here is an article based on the document you provided, written to your specifications.
The Next Leap in Blockchain Technology Fogo Explained
The dream of a truly global, ownerless computer has powered the evolution of blockchain technology for over a decade. Platforms like Ethereum and Solana have unlocked immense economic activity and a new wave of decentralized applications. Yet, despite their successes, a persistent critique remains: blockchains are often dismissed as slow databases, struggling to meet the performance demands of mainstream adoption. While protocols have become remarkably sophisticated in areas they can control, such as leader selection, fork choice rules, and runtime efficiency, they have largely ignored the most fundamental constraints of all: the laws of physics and the inherent messiness of globally distributed systems. A groundbreaking new layer 1 protocol named Fogo is poised to change this. @Fogo Official introduces a novel approach that confronts these physical limitations head on, aiming to deliver breakthrough improvements in transaction speed, latency, and overall network capacity. By reimagining the very foundation of blockchain architecture, Fogo presents a compelling vision for the future of decentralized computing.
Confronting the Unseen Barriers to Blockchain Speed
Most contemporary "fast chain" designs operate on a flawed premise. They implicitly assume away the physical realities of the networks they run on, treating latency as a mere nuisance and assuming a world of identical machines. Fogo argues that these are not inconveniences; they are the environment itself. Two powerful constraints perpetually govern the performance of any distributed system. The first is that latency is not a nuisance; it is the base layer. Signals propagating through fiber optic cables travel at roughly two thirds the speed of light, meaning a one way trip halfway around the globe takes about 100 milliseconds under ideal conditions. In reality, with network congestion, submarine cable layouts, and peering economics, a round trip time between continents can easily stretch from 70 milliseconds to over 170 milliseconds. Classic consensus protocols, which require multiple rounds of messages between validators to confirm a block, are therefore unavoidably bottlenecked by this internode communication time. The faster a chain tries to go, the more it fights against this fundamental propagation delay.
The second constraint is that the performance of a distributed system is dominated by its slowest components, not the average ones. This is the challenge of tail latency. In a decentralized network where an end to end operation spans numerous independent machines, the critical path is defined by the slowest validator you must wait for. A block is only committed after a sufficient quorum of validators has processed it and voted. If validator performance varies widely due to different hardware, software implementations, or network quality, the entire chain's real time behavior is governed by the slowest participants needed to reach that quorum. Blockchains that are oblivious to this variance in validator performance must necessarily settle for slower, less reliable update times. Fogo’s core philosophy is built upon directly addressing these two constraints. It advances two clear theses: first, that a blockchain aware of physical space can be faster than one that is not, and second, that a blockchain requiring high performance validator implementations can be faster than one that is not.
The Fogo Blockchain Architecture A New Paradigm
Fogo is not starting from scratch. It strategically builds upon the battle tested protocol and execution model pioneered by Solana, targeting maximum compatibility with the Solana Virtual Machine SVM. This intelligent design choice allows existing Solana programs, development tools, and infrastructure to migrate seamlessly to Fogo, gaining significant performance benefits while leveraging a familiar ecosystem. However, Fogo diverges from Solana in what it treats as first class design parameters: the geographic and network topology that messages must traverse, and the real world distribution of validator performance. To achieve its goals of low latency and high throughput, Fogo makes two critical architectural choices: localized consensus and performance enforcement. The rest of its architecture flows directly from these foundational decisions.
At its heart, $FOGO
implements the SVM through the open sourced Firedancer validator client, a next generation client engineered by Jump Crypto. Like Solana, blocks are proposed by a rotating leader selected through a deterministic, stake weighted algorithm. Consensus is achieved via Tower BFT, a Byzantine fault tolerant algorithm that creates an economic cost for validators who try to support multiple forks. A block is considered confirmed after receiving votes from over two thirds of the stake and is finalized once it reaches maximum lockout. Where Fogo innovates profoundly is in how this consensus is formed.
Localized Consensus Through Validator Zones
Fogo introduces a validator zone system, a mechanism for enabling geographic and temporal partitioning of the entire validator set. The network organizes validators into distinct zones, and critically, only one zone is actively participating in consensus during any given epoch. Validators in inactive zones remain connected and sync the chain, but they do not propose blocks, vote, or earn consensus rewards. This creates a rotating model where different subsets of the network take turns maintaining consensus.
Zone definitions and assignments are stored on chain as Program Derived Accounts, allowing for transparent governance. Fogo supports multiple strategies for selecting the active zone. One is epoch based rotation, where zones rotate sequentially based on the epoch number, ensuring each geographic group of validators gets a proportional amount of time as the active consensus set. A more dynamic approach is the "follow the sun" rotation. Here, zones can activate based on the UTC time of day rather than epoch boundaries. Each zone is assigned a duration, and the protocol calculates which zone should be active to align with peak usage hours in different regions around the world. This approach dramatically reduces latency for users by ensuring that the active consensus validators are geographically close to them. By shrinking the distance messages must travel on the critical path to consensus, #Fogo meaningfully improves network latency and finality times.
Performance Enforcement with the Firedancer Client
To combat tail latency and performance variance, Fogo standardizes on a highly optimized validator implementation based on Firedancer. The Fogo mainnet client, known as "Frankendancer," is a hybrid that combines Firedancer components with code from Agave, Solana's validator client. Its architecture is decomposed into independent functional units called "tiles," with each tile running as a separate sandboxed process pinned to a dedicated CPU core. This eliminates resource contention and context switching overhead, allowing each component to maximize its CPU utilization in a tight, predictable loop.
The core transaction processing pipeline consists of several specialized tiles. The Net tile receives packets directly from the network interface card. The QUIC tile reassembles transaction streams. Verify tiles perform cryptographic signature validation, an operation that is parallelized across multiple cores. The Dedup tile eliminates duplicate transactions. The Pack tile aggregates transactions into microblocks for the leader. The Bank tile executes transactions against the current state. The PoH tile maintains the Proof of History clock that timestamps operations. Finally, the Shred and Store tiles prepare blocks for distribution and persist them to the ledger.
This tile architecture unlocks immense throughput through several mechanisms. It allows for massive parallelism, especially in signature verification. It ensures predictable execution by pinning tiles to dedicated cores, keeping their caches hot. It employs a zero copy data flow, where transactions and blocks are passed between tiles using lightweight metadata pointers instead of copying large amounts of data, dramatically reducing memory bandwidth consumption. Furthermore, it uses features like AF_XDP for kernel bypass, creating a faster data path from the network card to the application. This meticulous, hardware aware design allows Fogo validators to approach the theoretical limits of performance.
Network Economics Sustainability and Incentives
Fogo’s economic model is designed to be sustainable and to properly incentivize network security. Transaction fees are designed to mirror Solana's. A simple transaction costs a base fee of 5,000 lamports. During times of congestion, users can add an optional priority fee or tip to increase the probability of their transaction being included. Half of the base fee is burned, creating a deflationary pressure on the token supply, while the other half is paid to the validator that processes the transaction. One hundred percent of any priority fees go directly to the block producer.
To manage the growth of on chain data, known as state bloat, Fogo also implements a rent mechanism. Accounts are charged for the storage space they consume at a set rate per byte per year. Half of this rent is burned and half is distributed to validators. This creates a powerful economic incentive for developers and users to be efficient with their resource usage. However, for most users, rent is experienced simply as a one time minimum balance requirement, as accounts that maintain this balance are considered rent exempt.
The network is secured through a fixed annual inflation rate of two percent. Newly minted tokens from inflation are distributed as rewards to validators and their delegated stakers. These rewards are calculated proportionally based on a points system, where points are earned for correctly validating blocks and participating in consensus. This system ensures that validators who provide high uptime and correct validation behavior generate higher returns for themselves and their delegators, aligning economic incentives with the security and health of the network.
Fogo Sessions Enabling a Seamless On Chain Experience
Beyond raw performance, Fogo is deeply focused on solving the critical user experience challenges that have hindered Web3 adoption. Fogo Sessions is an open source standard designed to address wallet compatibility issues, high transaction costs, and signature fatigue. It enables Web3 applications to deliver user experiences that are comparable to the seamlessness of traditional Web2 applications.
At its core, Sessions allows a user to grant time limited and narrowly scoped permissions to an application through a single initial signature. By signing a structured message or intent, the user creates a temporary session key that is stored securely in the browser. This session key is linked on chain to the user's primary wallet but can only perform actions specified in the original intent, such as interacting with certain programs or spending up to a certain limit of a specific token before an expiration time. With an active session, the application can submit transactions on the user’s behalf without requiring a popup or signature for every single action.
This model fundamentally transforms the user interaction paradigm. It also enables powerful features like fee sponsorship, where applications or third parties can pay transaction fees for users, creating a truly gasless experience. A developer could choose to sponsor fees for all users, or only for certain types of transactions, and could pay for these fees in native tokens, stablecoins, or other tokens. This infrastructure integrates seamlessly with Fogo’s built in token programs, layering temporary authorization on top of existing mechanisms without requiring a full redesign. Sessions has the potential to unlock new paradigms for applications in decentralized finance, gaming, and more by removing the most significant points of friction for end users.
Conclusion A New Foundation for the Global Computer
The history of blockchains has been a journey from fragile experiments to resilient global systems. The application layer has decisively proven the demand for an ownerless global computer. Yet modern usage is pushing up against the hard physical limits of network latency and validator variance. The Fogo thesis is that abstract consensus designs have reached their point of diminishing returns. The next great leap in performance and economic value will come from optimizing the entire physical stack. Fogo's claim is both straightforward and profound: a better global computer is reachable. By broadening the design space to address the real world systems and physical conditions under which blockchains must operate, Fogo is building a faster, more efficient, and more user friendly foundation for the next generation of the decentralized internet. It confronts the speed of light and the diversity of machines not as obstacles, but as core engineering parameters to be solved, unlocking a new frontier of performance and possibility.
#ALPHA🔥 $IP

Die Grundlage der Vanar Chain und die entscheidende Rolle der Validatoren
@Vanarchain steht als revolutionäre Layer-1-Blockchain-Infrastruktur, die speziell für die Unterhaltung, das Gaming und den Mainstream-Marken-Sektor entwickelt wurde. Im Zentrum dieses Ökosystems liegt das Validatorennetzwerk, das als fundamentale Sicherheitsschicht und Dezentralisierung fungiert. Im Gegensatz zu veralteten Systemen, die auf undurchsichtigen Prozessen basieren, nutzt Vanar ein transparentes und robustes Netzwerk globaler Validatoren, um sicherzustellen, dass jede einzelne Transaktion mit absoluter Integrität verarbeitet wird. Diese Validatoren sind die digitalen Türsteher, die einen nahtlosen Übergang von traditionellen Webarchitekturen zur dezentralen Zukunft von Web3 ermöglichen. Durch die Pflege des Hauptbuchs und die Validierung von Blöcken bieten diese Entitäten die vertrauenswürdige Umgebung, die notwendig ist, damit milliardenschwere Marken ohne Angst vor Sicherheitsverletzungen oder Systemausfällen auf der Blockchain agieren können.

Last but not least @Vanarchain still running on CreatorPad. This is the last campaign on CreatorPad, hope this month new camaign will be there as last month because last month there were 4 campaigns. $VANRY
current price is stable even up 2.89% as a writing a script. AI Slops does not work in Info-Fi world. Views and engagements mater on CreatorPad Points. Its has been 12 days but still I din't got any ranked. I suggest to all don't use AI contents just get help from the AI. Every one using AI and getting ranked I don't know how they are doing, but they are temporary gainers they are not creators.
As a Creator don't be fair. Consistency matter. #ALPHA🔥
#vanar

VanarChain (token: VANRY) is an AI-native Layer-1 blockchain platform designed to support real-world adoption through low-fee transactions, AI integration, PayFi solutions, and tokenized real-world assets. It aims to bridge enterprise, Web3, and mainstream use cases by combining high performance with smart infrastructure.
Capital Raised So Far
VanarChain has conducted funding rounds and token sales to support its development and ecosystem expansion. According to fundraising data, the project has raised approximately $2.61 million USD through various rounds, with the vast majority coming from private funding and only a small portion, roughly $105,000, from public sales.
This capital has helped establish the protocol’s foundation, support technical development, and bootstrap early ecosystem growth such as infrastructure tools, token staking, and community programs.
Tokenomics & Allocation
The token economics reveal how the funds are distributed and what role the token plays in the protocol’s growth. The total raised stands at approximately $2.61 million USD. The allocation structure shows that about 20.45% of tokens were assigned to private and pre-sale investors, while only about 0.40% were allocated to public sale participants. The total circulating supply is over 2.16 billion VANRY tokens, out of a maximum supply of 2.4 billion.
This structure indicates that most of the fundraising was completed privately, a common approach for blockchain projects seeking to secure early strategic backing before broader community distribution.
Strategic Partnerships as Indirect Funding Drivers
While there is limited public information on large venture capital checks from major institutional investors specifically for VANRY, VanarChain has been expanding its ecosystem through strategic partnerships that act as indirect funding and growth levers.
Integrations with launchpad tools like Ordify help projects on VanarChain run smoother fundraising campaigns and cross-chain token distribution, providing ecosystem lab support rather than a direct capital injection. Collaborations with custody providers like CeffuGlobal, a partner of Binance, enhance institutional security, drawing hedge funds and large holders into the network and signaling institutional confidence. Alliances with Web3 payment giants like WorldPay help extend VanarChain’s market reach into mainstream payments, offering another form of ecosystem validation even without traditional VC funding.
These partnerships are valuable because they reduce friction for adoption, enable cross-chain interoperability, and enhance credibility, all of which can attract future investors.
Ecosystem Growth and Funding Outlook
VanarChain is positioning itself not just as a blockchain but as an AI-enabled infrastructure stack that empowers developers and enterprises to build real-world applications. Its funding so far has laid the groundwork for continued growth, and its broad partnerships play a key role in attracting developer and institutional interest.
Looking ahead, the project could pursue further venture funding or ecosystem grants if it aims to accelerate adoption, expand developer rewards, or integrate more deeply with traditional industries such as finance, gaming, and AI services.
Conclusion
VanarChain’s current funding picture is modest but focused. With roughly $2.6 million raised to build its core platform, a strategic token allocation structure, and partnerships that help expand its ecosystem, the project has established a solid foundation. While it hasn’t publicly disclosed large venture capital fundraising rounds yet, its collaborations with infrastructure partners and custody providers point toward a growing foundation that could attract more capital and users as its technology and use cases continue to mature.
@Vanarchain #vanar $VANRY