diff --git a/app/[lang]/projects/page.tsx b/app/[lang]/projects/page.tsx
index 96c9ec03..596769de 100644
--- a/app/[lang]/projects/page.tsx
+++ b/app/[lang]/projects/page.tsx
@@ -1,12 +1,12 @@
 import { Metadata } from "next"
 import Image from "next/image"
 
+import { Divider } from "@/components/divider"
 import { PageHeader } from "@/components/page-header"
 import ProjectFiltersBar from "@/components/project/project-filters-bar"
 import { ProjectList } from "@/components/project/project-list"
 import { ProjectResultBar } from "@/components/project/project-result-bar"
 import { useTranslation } from "@/app/i18n"
-import { Divider } from "@/components/divider"
 
 export const metadata: Metadata = {
   title: "Project Library",
@@ -38,7 +38,7 @@ export default async function ProjectsPage({ params: { lang } }: any) {
       </PageHeader>
 
       <div className="w-full bg-white pb-28">
-        <div className="container flex flex-col gap-14 py-8">
+        <div className="container flex flex-col py-8 gap-14">
           <div>
             <ProjectResultBar lang={lang} />
           </div>
diff --git a/components/project/project-card.tsx b/components/project/project-card.tsx
index c9fe9947..7e4e4bdf 100644
--- a/components/project/project-card.tsx
+++ b/components/project/project-card.tsx
@@ -7,6 +7,7 @@ import { VariantProps, cva } from "class-variance-authority"
 
 import { ProjectInterface, ProjectLinkWebsite } from "@/lib/types"
 import { cn } from "@/lib/utils"
+import useContent from "@/hooks/useContent"
 import { useTranslation } from "@/app/i18n/client"
 import { LocaleTypes } from "@/app/i18n/settings"
 
@@ -54,10 +55,13 @@ export default function ProjectCard({
 }: ProjectCardProps & { lang: LocaleTypes }) {
   const { t } = useTranslation(lang, "common")
 
-  const { id, image, links, name, tldr, tags, imageAlt, projectStatus } =
-    project
+  const { id, image, links, name, tags, imageAlt, projectStatus } = project
 
   const projectNotActive = projectStatus !== "active"
+  const { projectContent } = useContent({
+    lang,
+    id,
+  })
 
   return (
     <Link
@@ -74,15 +78,15 @@ export default function ProjectCard({
             className="min-h-[160px] w-full overflow-hidden rounded-t-lg border-none object-cover"
           />
           {!image && (
-            <span className="absolute left-1/2 top-1/2 w-full -translate-x-1/2 -translate-y-1/2 px-5 text-center text-xl font-bold text-black">
+            <span className="absolute w-full px-5 text-xl font-bold text-center text-black -translate-x-1/2 -translate-y-1/2 left-1/2 top-1/2">
               {imageAlt || name}
             </span>
           )}
         </div>
       )}
-      <div className="flex h-full flex-col justify-between rounded-b-lg bg-white p-4">
+      <div className="flex flex-col justify-between h-full p-4 bg-white rounded-b-lg">
         <div className="flex flex-col justify-start gap-2">
-          <div className="mb-2 flex gap-2">
+          <div className="flex gap-2 mb-2">
             {tags?.themes?.map((theme, index) => {
               const { label } = ThemesButtonMapping(lang)?.[theme]
               const icon = TagsIconMapping?.[theme]
@@ -98,11 +102,11 @@ export default function ProjectCard({
             })}
           </div>
           <h1 className="text-xl font-bold text-black">{name}</h1>
-          <div className="flex h-28 flex-col gap-4">
-            <p className="text-slate-900/80">{tldr}</p>
+          <div className="flex flex-col gap-4 h-28">
+            <p className="text-slate-900/80">{projectContent?.tldr}</p>
           </div>
         </div>
-        <div className="mt-auto flex justify-between">
+        <div className="flex justify-between mt-auto">
           {showLinks && (
             <div className="flex items-center justify-start gap-3">
               {Object.entries(links ?? {})?.map(([website, url], index) => {
diff --git a/data/projects.ts b/data/projects.ts
index 541cc5c5..4802ba91 100644
--- a/data/projects.ts
+++ b/data/projects.ts
@@ -1,7 +1,6 @@
 import GithubIcon from "@/public/social-medias/github-fill.svg"
 import GlobeIcon from "@/public/social-medias/global-line.svg"
 import TwitterIcon from "@/public/social-medias/twitter-fill.svg"
-import i18next, { InitOptions } from "i18next"
 
 import { ProjectInterface, ProjectLinkType } from "@/lib/types"
 
@@ -21,11 +20,11 @@ import { jubmoji } from "./projects/jubmoji"
 import { maci } from "./projects/maci"
 import { maciRPGF } from "./projects/maci-rpgf"
 import { nfctap } from "./projects/nfctap"
+import { OpenPassport } from "./projects/openpassport"
 import { p0tion } from "./projects/p0tion"
 import { p256 } from "./projects/p256"
 import { pollenLabs } from "./projects/pollen-labs"
 import { PerpetualPowersOfTau } from "./projects/powers-of-tau"
-import { OpenPassport } from "./projects/openpassport"
 import { pseSecurity } from "./projects/pse-security"
 import { rln } from "./projects/rln"
 import { semaphore } from "./projects/semaphore"
@@ -50,24 +49,6 @@ export const ProjectLinkIconMap: ProjectLinkType = {
   twitter: TwitterIcon,
 }
 
-export const defineProjectTranslations = (
-  resources: InitOptions["resources"] = {}
-) => {
-  const languageCode = location?.pathname.split("/")[1]
-  console.log("languageCode", languageCode)
-  return null
-  i18next.init({
-    lng: languageCode, // if you're using a language detector, do not define the lng option
-    debug: true,
-    resources: {
-      en: {
-        translation: {
-          tldr: "hello world",
-        },
-      },
-    },
-  })
-}
 /**
  * List of Projects
  *
diff --git a/data/projects/README.md b/data/projects/README.md
index a30568c1..c2be8a34 100644
--- a/data/projects/README.md
+++ b/data/projects/README.md
@@ -1,5 +1,8 @@
 ## Add new project to projects list
 
+
+
+
 ####  1. Create a New Project File:
   - Navigate to the [...]/data/projects folder within your project directory.
  - Inside this folder, create a new file named [project_name].ts.
@@ -8,6 +11,8 @@
  - Open the newly created [project_name].ts file.
  - To ensure all necessary parameters are included, use the ProjectInterface template. Here's a basic structure to get you started:
 
+**Note**: The `description` and `tldr` are now managed through the respective translation file located in /i18n/locales. Refer to step #4 for more details.
+
 ```js
 export const project_name: ProjectInterface = {
   id: "project_name",
@@ -37,6 +42,20 @@ const projects: ProjectInterface[] = [
 ];
 ```
 
+#### 4. Project Description and TLRD
+With the project now supporting multiple languages, the description and content fields are managed in the internalization folder. Follow these steps:
+- Create a new project_id.json file in /app/i18n/locales/${lang}/projects/${project_id}.json.
+- Ensure the project_id defined in Step 2 matches the project_id.json file.
+- In this new file, add the description and tldr for the project.
+- Repeat these steps for each language you wish to support.
+
+```json
+{
+  "description": "project description content",
+  "tldr": "project tldr"
+}
+```
+
 By following these steps, you will successfully add a new project and ensure it is correctly registered and visible.
 
 ## Show badges in the project card
@@ -68,8 +87,6 @@ export const example: ProjectInterface = {
   id: "example",
   image: "",
   name: "This is an example of the project",
-  tldr: 'The project one-liner',
-  description: 'A longer project description',
   projectStatus: '',
   tags: {
     themes: ["play", "buildWith"],
diff --git a/data/projects/anon-aadhaar.ts b/data/projects/anon-aadhaar.ts
index 9c0e1fe9..d2db9337 100644
--- a/data/projects/anon-aadhaar.ts
+++ b/data/projects/anon-aadhaar.ts
@@ -1,17 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-Anon Aadhaar is a project that allows individuals to prove their citizenship anonymously. The project provides circuits, an SDK, and demo applications that generate and verify proofs of valid Aadhaar cards, integrating with the PCD framework to support a wide range of applications.
-`
-
 export const anonAadhaar: ProjectInterface = {
   id: "anon-aadhaar",
   section: "pse",
   projectStatus: "active",
   image: "anon-aadhaar.svg",
   name: "Anon Aadhaar",
-  tldr: "Tools for building build privacy-preserving applications using government ID cards, specifically Aadhaar cards in India.",
-  description,
   links: {
     website: "https://anon-aadhaar.pse.dev/",
     github: "https://github.com/privacy-scaling-explorations/anon-aadhaar",
diff --git a/data/projects/anon-klub.ts b/data/projects/anon-klub.ts
index 228c4112..9bac1f6d 100644
--- a/data/projects/anon-klub.ts
+++ b/data/projects/anon-klub.ts
@@ -1,17 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-AnonKlub is a tool designed for Ethereum developers that allows for anonymous proof of Ethereum address ownership. It doesn't directly address the public observability of Ethereum transactions but provides a workaround for privacy. Users can prepare a list of Ethereum addresses, sign a message from an address they own, and use that signature to generate a zero-knowledge proof. This proof enables users to perform actions anonymously that would typically require ownership of an address from the initial list. Use cases include anonymous NFT minting and Discord verification for DAOs without disclosing the public address.
-`
-
 export const anonKlub: ProjectInterface = {
   id: "anon-klub",
   section: "pse",
   projectStatus: "inactive",
   image: "anonklub.svg",
   name: "AnonKlub",
-  tldr: "A mechanism for anonymous proof of Ethereum address ownership.",
-  description,
   links: {
     github: "https://github.com/anonklub",
     website: "https://anonklub.github.io",
diff --git a/data/projects/bandada.ts b/data/projects/bandada.ts
index 3106500a..b1ecbeff 100644
--- a/data/projects/bandada.ts
+++ b/data/projects/bandada.ts
@@ -1,17 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-Bandada is a project designed to simplify the management of privacy-preserving Semaphore groups. It is aimed at developers who want to build privacy-based applications and integrate anonymity sets, as well as non-developers working in DAOs, governments, international institutions, non-profit organizations, and associations that want to create and manage anonymous groups. Bandada offers a plug-and-play infrastructure, reducing the time and complexity required for managing anonymity sets. It enables anonymous signaling, such as voting, messaging, login, or endorsing, in various use cases like private organizations, GitHub repository contributors, and groups of wallets holding a specific NFT.
-`
-
 export const bandada: ProjectInterface = {
   id: "bandada",
   section: "pse",
   projectStatus: "active",
   image: "bandada.webp",
   name: "Bandada",
-  tldr: "An open-source system for managing privacy-preserving groups of anonymous individuals.",
-  description,
   links: {
     github: "https://github.com/privacy-scaling-explorations/bandada",
     website: "https://bandada.pse.dev",
diff --git a/data/projects/channel-4.ts b/data/projects/channel-4.ts
index d813fe46..95e23067 100644
--- a/data/projects/channel-4.ts
+++ b/data/projects/channel-4.ts
@@ -1,17 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-Channel 4 is a community-driven platform where users can submit and discover content. It uses state channels to incentivize user engagement. When a user likes the content you've submitted, a state channel closes and rewards are dropped into their wallet. This approach combines entertainment with the power of state channels, enabling community members to earn while they engage.
-`
-
 export const channel4: ProjectInterface = {
   id: "channel-4",
   section: "pse",
   projectStatus: "inactive",
   image: "channel4.svg",
   name: "Channel 4",
-  tldr: "Content discovery through community contributions, using state channels to reward users for popular posts.",
-  description,
   links: {
     github: "https://github.com/State-Channel-4",
     website: "https://channel4.wtf/",
diff --git a/data/projects/chiquito.ts b/data/projects/chiquito.ts
index c5f30131..a0c22fc9 100644
--- a/data/projects/chiquito.ts
+++ b/data/projects/chiquito.ts
@@ -1,26 +1,26 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-Chiquito is a high-level structured language for implementing zero knowledge proof circuits, currently being implemented in the DSL Working Group of PSE. It is a state machine zk-language that provides better syntax and abstraction. It can automatically compiler arbitrary boolean expressions for state machine transitions. It can optimise the resulting arithmetization. Chiquito has a Halo2 backend, which is a low level zkDSL that writes circuits using the PLONKish arithmetization and is working on supporting additional backends. Chiquito circuits can be written using both Python and Rust. 
-`
-
 export const chiquito: ProjectInterface = {
-    id: "chiquito",
-    section: "pse",
-    projectStatus: "active",
-    image: "",
-    name: "chiquito",
-    tldr: "A modern ZKP language and compiler for plonkish and AIR arithmetizations",
-    description,
-    links: {
-        github: "https://github.com/privacy-scaling-explorations/chiquito",
-        website: "https://docs.pecadorplonkish.xyz/",
-        twitter: "",
-    },
-    tags: {
-        themes: ["build"],
-        types: ["Legos/dev tools", "Lego sets/toolkits", "Proof of concept", "language", "dsl"],
-        keywords: ["DSL", "language", "rust", "python", "halo2"],
-        builtWith: ["halo2", "rust"],
-    },
-}
\ No newline at end of file
+  id: "chiquito",
+  section: "pse",
+  projectStatus: "active",
+  image: "",
+  name: "chiquito",
+  links: {
+    github: "https://github.com/privacy-scaling-explorations/chiquito",
+    website: "https://docs.pecadorplonkish.xyz/",
+    twitter: "",
+  },
+  tags: {
+    themes: ["build"],
+    types: [
+      "Legos/dev tools",
+      "Lego sets/toolkits",
+      "Proof of concept",
+      "language",
+      "dsl",
+    ],
+    keywords: ["DSL", "language", "rust", "python", "halo2"],
+    builtWith: ["halo2", "rust"],
+  },
+}
diff --git a/data/projects/coco.ts b/data/projects/coco.ts
index 2a0f74b2..525c8de2 100644
--- a/data/projects/coco.ts
+++ b/data/projects/coco.ts
@@ -5,9 +5,6 @@ export const Coco: ProjectInterface = {
   section: "pse",
   image: "coco.svg",
   name: "COCO",
-  tldr: "Integrating Nova into the EVM involves wrapping Liam Eagen's theoretical ECIP argument in Halo 2",
-  description:
-    "With Coco, groups can collaborate to curate feeds of any topic they're interested in. As you scroll through your Coco feed, rather than upvoting or downvoting posts, you'll spend WETH to predict what other group members and the group's moderators will want to see. When you're right, you'll get back your original WETH and more — but if you're wrong, you'll lose what you put in. Through this process, you help Coco filter value from noise to make sure group feeds only consist of posts that the group cares about.",
   projectStatus: "inactive",
   tags: {
     keywords: ["prediction market", "scaling"],
diff --git a/data/projects/cryptkeeper.ts b/data/projects/cryptkeeper.ts
index 91fcfc48..e2e6bd69 100644
--- a/data/projects/cryptkeeper.ts
+++ b/data/projects/cryptkeeper.ts
@@ -1,17 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-CryptKeeper is a browser extension that generates Semaphore and RLN proofs for websites, providing a secure and portable solution for managing anonymous identity secrets across different applications. It simplifies the integration of zero-knowledge (ZK) identities and proofs into applications, allowing developers to focus on building the front-end and logic of their applications. By handling complex aspects of cryptography, circuits, caching, and storage, CryptKeeper enables users to interact with decentralized applications (dapps) without revealing their private identity secrets. It is aimed at building secure community standards for the growing ZK ecosystem.
-`
-
 export const cryptkeeper: ProjectInterface = {
   id: "cryptkeeper",
   section: "pse",
   projectStatus: "inactive",
   image: "cryptkeeper.webp",
   name: "CryptKeeper",
-  tldr: "A browser extension for secure, portable anonymous identity management across applications.",
-  description,
   links: {
     github: "https://github.com/CryptKeeperZK",
   },
diff --git a/data/projects/discreetly.ts b/data/projects/discreetly.ts
index 4d1fd17c..40f422f6 100644
--- a/data/projects/discreetly.ts
+++ b/data/projects/discreetly.ts
@@ -1,17 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-An anonymous, federated, chat application that uses Rate-Limiting Nullifier for spam prevention.
-`
-
 export const discreetly: ProjectInterface = {
   id: "discreetly",
   section: "pse",
   projectStatus: "active",
   image: "discreetly.svg",
   name: "Discreetly",
-  tldr: "An anonymous, federated, chat application using ZK.",
-  description,
   links: {
     github: "https://github.com/Discreetly",
     website: "https://app.discreetly.chat/",
diff --git a/data/projects/dsl-working-group.ts b/data/projects/dsl-working-group.ts
index 67bd4c11..2cf7a7b3 100644
--- a/data/projects/dsl-working-group.ts
+++ b/data/projects/dsl-working-group.ts
@@ -1,9 +1,5 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-The DSL Working Group is focused on the exploration and improvement of languages used to write zero-knowledge circuits. The group's primary goal is to enhance the state of zk circuit languages, making them easier to write and review by offering the right abstractions. They also aim to make it harder to write unsound circuits by implementing static analysis and enforcing safer patterns. Additionally, they are working to support next-generation (Incrementally Verifiable Computation or IVC) proving systems. The group is currently working on Chiquito, a high-level Domain-Specific Language (DSL) for Halo2 circuits that lowers the entry barrier to write zk circuits with a state-machine abstraction API.
-`
-
 export const dslWorkingGroup: ProjectInterface = {
   id: "dsl-working-group",
   section: "pse",
@@ -11,8 +7,6 @@ export const dslWorkingGroup: ProjectInterface = {
   image: "",
   imageAlt: "DSL Working Group",
   name: "DSL Working Group",
-  tldr: "Exploration of languages for writing zk circuits",
-  description,
   links: {
     github: "https://github.com/privacy-scaling-explorations/chiquito/",
   },
diff --git a/data/projects/ecip-halo2.ts b/data/projects/ecip-halo2.ts
index 34563b10..8a8db83c 100644
--- a/data/projects/ecip-halo2.ts
+++ b/data/projects/ecip-halo2.ts
@@ -6,8 +6,6 @@ export const ECIPHalo2: ProjectInterface = {
   image: "",
   imageAlt: "ECIP + Halo 2",
   name: "ECIP (Elliptic Curve Inner Products) Halo 2 Implementation",
-  tldr: "Integrating Nova into the EVM involves wrapping Liam Eagen's theoretical ECIP argument in Halo 2",
-  description: `Liam Eagen has developed a ZK proof for Elliptic Curve Inner Products (ECIPs) to overcome a significant bottle neck in recursive proof composition over elliptic curve cycles. The p1rocess of integrating Nova into the EVM requires an efficient method or "argument" for handling large elliptic Multi-Scalar Multiplications (MSMs). The final step in this integration process involves wrapping this argument Halo 2.`,
   projectStatus: "active",
   links: {
     github: "https://github.com/levs57/sage-circuits/",
diff --git a/data/projects/eigen-trust.ts b/data/projects/eigen-trust.ts
index b5af93ff..c32b3f11 100644
--- a/data/projects/eigen-trust.ts
+++ b/data/projects/eigen-trust.ts
@@ -1,17 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-EigenTrust is a library designed to manage trust within a distributed network, incorporating zero-knowledge features. It serves as a reputation bank for the Ethereum ecosystem, providing an interoperable layer for managing reputation and trust. The protocol creates zero-knowledge proofs of reputation scores based on ratings given by network participants. This allows for the creation of a reputation system for peer-to-peer marketplaces and exchanges, reputation-weighted voting, and community gatekeeping.
-`
-
 export const eigenTrust: ProjectInterface = {
   id: "eigen-trust",
   section: "pse",
   projectStatus: "inactive",
   image: "",
   name: "EigenTrust",
-  tldr: "A distributed reputation system with zero-knowledge features.",
-  description,
   links: {
     github: "https://github.com/eigen-trust/protocol",
   },
diff --git a/data/projects/interep.ts b/data/projects/interep.ts
index f8958ccd..d9f3fa66 100644
--- a/data/projects/interep.ts
+++ b/data/projects/interep.ts
@@ -5,9 +5,6 @@ export const Interep: ProjectInterface = {
   section: "pse",
   image: "interep.svg",
   name: "Interep",
-  tldr: "An identity bridge from web2 to web3",
-  description:
-    "Interep aims to provide an identity solution for Ethereum users by bridging from an established digital identity source such as Reddit, Twitter, and Github. The product provides an identity layer in the application stack and uses the Semaphore framework to ensure privacy. Interep allows users to establish sybil-resistant decentralized identities on web3 without starting from scratch. By leveraging zero-knowledge proofs, Interep ensures only essential information is disclosed.",
   projectStatus: "inactive",
   tags: {
     keywords: ["social", "reputation"],
diff --git a/data/projects/jubmoji.ts b/data/projects/jubmoji.ts
index e50450f1..24d24a58 100644
--- a/data/projects/jubmoji.ts
+++ b/data/projects/jubmoji.ts
@@ -1,17 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-Jubmoji.quest is a place to keep personal, provable digital mementos from people you meet and places you visit IRL. Each time you tap a card, you collect a Jubmoji, a unique cryptographic signature that you can store privately and share as you wish!
-`
-
 export const jubmoji: ProjectInterface = {
   id: "jubmoji",
   section: "pse",
   projectStatus: "active",
   image: "",
   name: "jubmoji.quest",
-  tldr: "Users of Jubmoji.quest tap NFC cards to collect signatures. By collecting these signatures, they complete quests.",
-  description,
   links: {
     github: "https://github.com/jubmoji/jubmoji.quest",
     website: "https://www.jubmoji.quest/",
diff --git a/data/projects/maci-rpgf.ts b/data/projects/maci-rpgf.ts
index fbb478e6..b4128311 100644
--- a/data/projects/maci-rpgf.ts
+++ b/data/projects/maci-rpgf.ts
@@ -1,17 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-MACI-RPGF is an implementation of EasyRetroPGF with MACI. This project quickly enables any community, organization or ecosystem to run an optimism-style rpgf round. It is highly configurable to enable different gating mechanisms (token based, attestation based, hats-based, etc) and an easy-to-use UI for both: round organizers and voters.
-`
-
 export const maciRPGF: ProjectInterface = {
   id: "maci-rpgf",
   section: "pse",
   projectStatus: "active",
   image: "maci-rpgf.png",
   name: "MACI RPGF",
-  tldr: "Run your optimism-style rpgf round in your community! Forked from EasyRetroPGF and enhanced with MACI for privacy, anti-bribery and anti-collusion",
-  description,
   links: {
     github: "https://github.com/privacy-scaling-explorations/maci-rpgf",
     website: "https://maci.pse.dev",
diff --git a/data/projects/maci.ts b/data/projects/maci.ts
index 294d0605..ffdac1ca 100644
--- a/data/projects/maci.ts
+++ b/data/projects/maci.ts
@@ -1,17 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-Minimal Anti-Collusion Infrastructure (MACI) is a protocol designed to provide a highly secure e-voting solution. It enables organizations to conduct on-chain voting processes with a significantly reduced risk of cheating, such as bribery or collusion. MACI uses zero-knowledge proofs to implement a receipt-free voting scheme, making it impossible for anyone other than the vote coordinator to verify how a specific user voted. This ensures the correct execution of votes and allows anyone to verify the results. It's particularly beneficial for governance and funding events, where its anti-collusion mechanisms help ensure fair and transparent outcomes.
-`
-
 export const maci: ProjectInterface = {
   id: "maci",
   section: "pse",
   projectStatus: "active",
   image: "maci.png",
   name: "MACI",
-  tldr: "An on-chain voting solution that protects privacy and minimizes the risk of collusion and bribery",
-  description,
   links: {
     github: "https://github.com/privacy-scaling-explorations/maci",
     website: "https://maci.pse.dev",
diff --git a/data/projects/nfctap.ts b/data/projects/nfctap.ts
index 97d11407..95b65c43 100644
--- a/data/projects/nfctap.ts
+++ b/data/projects/nfctap.ts
@@ -1,17 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-NFC activations at SBC and FtC residency
-`
-
 export const nfctap: ProjectInterface = {
   id: "nfctap",
   section: "pse",
   projectStatus: "active",
   image: "",
   name: "nfctap.xyz",
-  tldr: "This project was built to activate NFCs at SBC and FtC and learn from it for a larger Devconnect experience with 200 cards and 5,000 attendees.",
-  description,
   links: {
     github: "https://github.com/jubmoji/nfctap.xyz",
     website: "https://www.nfctap.xyz/",
diff --git a/data/projects/openpassport.ts b/data/projects/openpassport.ts
index ee167090..b6a74441 100644
--- a/data/projects/openpassport.ts
+++ b/data/projects/openpassport.ts
@@ -1,17 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-OpenPassport is developing tools to let users generate proofs of humanity, nationality and age using their government-issued passport. It unlocks uses cases in proof of unique identity, sybil resistance and selective disclosure of private data.
-`
-
 export const OpenPassport: ProjectInterface = {
   id: "openpassport",
   section: "grant",
   projectStatus: "active",
   image: "openpassport.jpg",
   name: "OpenPassport",
-  tldr: "OpenPassport lets you check a passport is valid in zero-knowledge",
-  description,
   links: {
     github: "https://github.com/zk-passport/openpassport",
     website: "https://openpassport.app",
diff --git a/data/projects/p0tion.ts b/data/projects/p0tion.ts
index 7c0e8dcf..43c1d2f0 100644
--- a/data/projects/p0tion.ts
+++ b/data/projects/p0tion.ts
@@ -1,17 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-p0tion is an agnostic-from-ceremony public good toolkit, with the aim of making Groth16 zk-applications scale and become production-ready in a safe and secure manner by running Phase 2 Trusted Setup ceremonies.
-`
-
 export const p0tion: ProjectInterface = {
   id: "p0tion",
   section: "pse",
   projectStatus: "active",
   image: "p0tion.png",
   name: "p0tion",
-  tldr: "Toolkit for Groth16 Phase 2 Trusted Setup ceremonies.",
-  description,
   links: {
     website: "https://ceremony.pse.dev/",
     github: "https://github.com/privacy-scaling-explorations/p0tion",
diff --git a/data/projects/p256.ts b/data/projects/p256.ts
index 33389459..06e9c626 100644
--- a/data/projects/p256.ts
+++ b/data/projects/p256.ts
@@ -1,17 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-P256 is an ERC-4337 smart contract wallet that leverages zk-SNARKs for WebAuthn and P-256 signature verification. It aims to simplify Ethereum transactions by incorporating familiar authentication methods like touchID and faceID. The project addresses the challenges of seed phrase management and leverages the biometric capabilities of billions of cellphones to create a more user-friendly crypto experience. Technically, it is an end-to-end ERC-4337 smart contract wallet that verifies ZK proofs of Passkey signatures using the Halo2 proving system.
-`
-
 export const p256: ProjectInterface = {
   id: "p256",
   section: "pse",
   projectStatus: "active",
   image: "",
   name: "P256",
-  tldr: "Smart contract wallet enabling transactions through familiar flows like touchID, faceID, WebAuth, and Passkeys.",
-  description,
   links: {
     website: "https://www.p256wallet.org/",
     github: "https://github.com/privacy-scaling-explorations/p256-circom",
diff --git a/data/projects/pollen-labs.ts b/data/projects/pollen-labs.ts
index 4582bf11..eeff45d7 100644
--- a/data/projects/pollen-labs.ts
+++ b/data/projects/pollen-labs.ts
@@ -1,24 +1,15 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-Pollen Labs is driven by a mission to make a significant impact on global lives by addressing complex, pressing issues. We work alongside the community to break barriers, preserve privacy, and build a future where every voice is heard, and a free web is accessible to all. Our projects, like Channel 4, a content discovery engine, and Daisy, focusing on information transparency, embody this mission., enabling community members to earn while they engage.
-
-We are a small team with a diverse skillset including design, engineering, community growth, and operations. We serve as a product accelerator, facilitating solutions to real-world problems with advanced blockchain technology. Our core value as follow:
-
-`
-
 export const pollenLabs: ProjectInterface = {
   id: "pollen-labs",
   section: "collaboration",
   projectStatus: "inactive",
   image: "pollen-labs.svg",
   name: "Pollen Labs",
-  tldr: "Building a better world through open-source & blockchain technology.",
-  description,
   links: {
     website: "https://pollenlabs.org/",
     twitter: "https://twitter.com/PollenLabs_",
-    discord: "https://discord.gg/5B3jP2sgWS" ,
+    discord: "https://discord.gg/5B3jP2sgWS",
   },
   tags: {
     keywords: ["Anonymity/privacy", "Scaling", "Public good"],
diff --git a/data/projects/powers-of-tau.ts b/data/projects/powers-of-tau.ts
index 48c209ba..10311fe8 100644
--- a/data/projects/powers-of-tau.ts
+++ b/data/projects/powers-of-tau.ts
@@ -5,9 +5,6 @@ export const PerpetualPowersOfTau: ProjectInterface = {
   section: "pse",
   image: "powers-of-tau.png",
   name: "Perpetual Powers of Tau",
-  tldr: "An ongoing (since 2019) zk-SNARK trusted setup ceremony for circuits up to 2^28 constraints.",
-  description:
-    "The Perpetual Powers of Tau is a multi-party trusted setup ceremony, rooted in the Zcash Powers of Tau. Its primary objective is the secure generation of zk-SNARK parameters for circuits accommodating up to 2^28 (260+ million) constraints. This translates to the creation of over 530 million powers of tau. The ceremony's integrity hinges on the principle that as long as one participant acts honestly and remains uncompromised, the entire setup remains trustworthy. It's a pivotal step for zk-SNARK projects, ensuring the security and privacy of the system. Those who can handle a 100Gb download and many hours of compute time are invited to join by contacting [@glamperd on Twitter](https://twitter.com/glamperd) or Telegram, or asking questions via the PSE [Discord](https://discord.com/invite/sF5CT5rzrR).",
   projectStatus: "active",
   tags: {
     keywords: ["scaling"],
diff --git a/data/projects/pse-security.ts b/data/projects/pse-security.ts
index f2e87aca..1e660809 100644
--- a/data/projects/pse-security.ts
+++ b/data/projects/pse-security.ts
@@ -1,17 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-PSE Security is a division of the Privacy & Scaling Explorations team at the Ethereum Foundation. Its primary goal is to identify and rectify bugs, thereby enhancing the security of the Ethereum Layer 2 and Zero-Knowledge ecosystems. Recognizing the potential for critical bugs to cause significant setbacks, PSE Security is committed to preemptively addressing these issues. The team offers open-source projects like the ZK Bug Tracker and Bridge Bug Tracker, which track real bugs and exploits in production code, and encourages community contributions. PSE Security also conducts manual audits and plans to help teach the community more about security and ways they can prevent bugs themselves.
-`
-
 export const pseSecurity: ProjectInterface = {
   id: "pse-security",
   section: "pse",
   projectStatus: "active",
   image: "pse-security.png",
   name: "PSE Security",
-  tldr: "Proactively securing Ethereum's L2 and ZK ecosystems.",
-  description,
   links: {
     github: "https://github.com/privacy-scaling-explorations/security",
   },
diff --git a/data/projects/rln.ts b/data/projects/rln.ts
index 138e6714..d2189f3c 100644
--- a/data/projects/rln.ts
+++ b/data/projects/rln.ts
@@ -1,17 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-Rate-Limiting Nullifier (RLN) is a protocol designed to combat spam and denial of service attacks in privacy-preserving environments. It allows users in an anonymous system to penalize those who exceed the rate limit, either by withdrawing the offender's stake or revealing their secrets. This mechanism helps maintain system integrity and deters abuse. RLN is built on the Semaphore protocol and uses zero-knowledge proofs and the Shamir’s Secret Sharing scheme to reveal the spammer's private key. It's particularly useful for developers working on communication systems that require privacy and anonymity, such as chat apps, client-server communications, and peer-to-peer communications. It's already being used in projects like Zerokit and Waku, and is also being developed for use with the KZG polynomial commitment scheme.
-`
-
 export const rln: ProjectInterface = {
   id: "rln",
   section: "pse",
   projectStatus: "active",
   image: "rln.svg",
   name: "Rate-Limiting Nullifier",
-  tldr: "A protocol for deterring spam and maintaining anonymity in communication systems.",
-  description,
   links: {
     github: "https://github.com/Rate-Limiting-Nullifier/circom-rln",
     website: "https://rate-limiting-nullifier.github.io/rln-docs/",
diff --git a/data/projects/semaphore.ts b/data/projects/semaphore.ts
index 1e468e53..c97ad02b 100644
--- a/data/projects/semaphore.ts
+++ b/data/projects/semaphore.ts
@@ -1,9 +1,5 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-Semaphore is a protocol that allows users to prove their membership in a group and transmit anonymous data, such as votes or feedback, without revealing their identities. It is designed for developers aiming to build privacy-preserving applications. Semaphore enables the creation of identities and their corresponding public value, which can be added to Merkle trees. This facilitates the authentication of anonymous user messages through zero-knowledge proofs, where membership is proven using Merkle proofs within the circuit. Key use cases include anonymous voting applications, receiving anonymous feedback from event attendees, and anonymous text messages. It is currently in production and is being used in a wide variety of projects.
-`
-
 export const semaphore: ProjectInterface = {
   id: "semaphore",
   section: "pse",
@@ -12,8 +8,6 @@ export const semaphore: ProjectInterface = {
   previousBrandImage: "semaphorePrevious.jpg",
   license: "MIT",
   name: "Semaphore",
-  tldr: "A zero-knowledge protocol for anonymous interactions.",
-  description,
   links: {
     github: "https://github.com/semaphore-protocol",
     website: "https://semaphore.pse.dev/",
diff --git a/data/projects/summa.ts b/data/projects/summa.ts
index d6f1064d..2888b85b 100644
--- a/data/projects/summa.ts
+++ b/data/projects/summa.ts
@@ -1,17 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-Summa allows centralized exchanges to demonstrate that their assets exceed their liabilities without revealing critical business information such as individual user balances, total number of users, and total liabilities or assets. It uses zero-knowledge proofs to ensure that exchanges can demonstrate they have sufficient assets to cover all user balances. The protocol involves building a Merkle Sum Tree of user balances, generating proofs for each user, and allowing users to verify these proofs.
-`
-
 export const summa: ProjectInterface = {
   id: "summa",
   section: "pse",
   projectStatus: "active",
   image: "summa.svg",
   name: "Summa",
-  tldr: "Protocol enabling centralized exchanges to prove solvency without compromising private information.",
-  description,
   links: {
     github: "https://github.com/summa-dev",
   },
diff --git a/data/projects/tlsn.ts b/data/projects/tlsn.ts
index fec4d315..e0e0510c 100644
--- a/data/projects/tlsn.ts
+++ b/data/projects/tlsn.ts
@@ -1,19 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-TLSNotary is ideal for developers of privacy-focused projects that require **data provenance** from secure web servers. It leverages the widely-used **Transport Layer Security (TLS)** protocol to securely and privately prove that a transcript of communications with a web server took place. The protocol divides TLS session keys between two parties: the Prover and the Verifier, using **Multi-Party Computation (MPC)**.  Neither the User nor Notary are in possession of the full TLS session keys, they only hold a share of those keys. This retains the security assumptions of TLS while allowing the Prover to demonstrate the **authenticity of the communication** to the Verifier. The Verifier remains unaware of which webserver is being queried, and the Verifier never has access to the unencrypted communications, except for the data the Prover explicitly wants to disclose.
-
-**TLSNotary can help your project with secure and privacy-preserving data portability!**
-`
-
 export const tlsn: ProjectInterface = {
   id: "tlsn",
   section: "pse",
   projectStatus: "active",
   image: "tlsn.webp",
   name: "TLSNotary",
-  tldr: "A protocol for creating cryptographic proofs of authenticity for any data on the web.",
-  description,
   links: {
     github: "https://github.com/tlsnotary/tlsn",
     website: "https://tlsnotary.org/",
diff --git a/data/projects/trusted-setups.ts b/data/projects/trusted-setups.ts
index be213e42..f99608eb 100644
--- a/data/projects/trusted-setups.ts
+++ b/data/projects/trusted-setups.ts
@@ -1,16 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-The Trusted Setups project is dedicated to simplifying the process of trusted setups, which are crucial for privacy or scaling solutions. Trusted setups involve multiple participants contributing to the generation of secrets. As long as one participant forgets their part of the secret, the final solution remains secure. The team recognizes the complexity of developing contribution programs and coordinating the participants' queue in a trusted setup. To address this, they are developing tools, including scripts, WebApps, and APIs, to streamline the contribution and coordination effort. This allows developers to focus on building their circuits and applications, enhancing efficiency and productivity in the development of zero-knowledge applications.
-`
 export const trustedSetups: ProjectInterface = {
   id: "trusted-setups",
   section: "pse",
   projectStatus: "active",
   image: "trusted-setups.svg",
   name: "Trusted Setups",
-  tldr: "Aiding developers with tools for trusted setups.",
-  description,
   links: {
     github: "https://github.com/zkparty",
   },
diff --git a/data/projects/unirep-protocol.ts b/data/projects/unirep-protocol.ts
index f415775b..a292f94c 100644
--- a/data/projects/unirep-protocol.ts
+++ b/data/projects/unirep-protocol.ts
@@ -1,11 +1,5 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-UniRep is a zero-knowledge protocol that securely manages user data through anonymous identifiers, enabling trustless interactions and enhanced user privacy in applications. UniRep expands the notion of reputation to include various user data aspects, such as preferences, activity, alignments, and ownership.
-
-Using anonymous identifiers (epoch keys), the protocol allows for trustless engagement with applications while preserving user privacy. This approach promotes non-custodial applications that don't hold user data, reducing data breach risks and emphasizing security for both users and developers.
-`
-
 export const unirepProtocol: ProjectInterface = {
   id: "unirep-protocol",
   section: "pse",
@@ -14,8 +8,6 @@ export const unirepProtocol: ProjectInterface = {
   license: "MIT",
   previousBrandImage: "unirep-previousBrand.png",
   name: "UniRep Protocol",
-  tldr: "A Zero-Knowledge Protocol built to handle anonymous user data.",
-  description,
   links: {
     github: "https://github.com/Unirep",
     website: "https://developer.unirep.io/docs/welcome",
diff --git a/data/projects/voice-deck.ts b/data/projects/voice-deck.ts
index 3c7df172..bee05c40 100644
--- a/data/projects/voice-deck.ts
+++ b/data/projects/voice-deck.ts
@@ -1,18 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-
-const description = `
-VoiceDeck isn't just a platform; it's a movement. By enabling citizens to fund journalism that makes a real difference, we're crafting a narrative where every contribution paints a stroke on the canvas of our collective future. Join us to foster a legacy where journalism is powered by the very communities it serves.
-`
-
 export const voicedeck: ProjectInterface = {
   id: "voice-deck",
   section: "collaboration",
   projectStatus: "active",
   image: "voiceDeck.svg",
   name: "VoiceDeck",
-  tldr: "From Individual Actions to Collective Impact, Every Voice Makes a Difference",
-  description,
   links: {
     github: "https://github.com/VoiceDeck",
     website: "https://voicedeck.org/",
diff --git a/data/projects/wax.ts b/data/projects/wax.ts
index 89f76b04..99398643 100644
--- a/data/projects/wax.ts
+++ b/data/projects/wax.ts
@@ -1,23 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-Wallet Account eXperiments (WAX), formerly "BLS Wallet", is a set of smart account components to augment wallets, dApps and SDKs. Transaction verification leverages existing cryptographic primitives, wrapped as modules/plugins, to verify the validity of different signature and proof types.
-
-Samples combining primitives intends to show what is possible, and how to readily take advantage of the primitives.
-Eg, using BLS signatures enables aggregation on L2s and thus gas savings on L1. Or webauthN as a supplementary mechanism to authorise large transactions. ZKEmail for social recovery via emails, ...
-
-Whilst implemented within a few 4337 compatible smart accounts (starting with Safe), a supplementary minimal implementation exists to isolate and showcase modular smart account components with action permissions.
-The primary use cases for WAX include scaling, key management, and the creation of prototypes for the web3 ecosystem.
-`
-
 export const wax: ProjectInterface = {
   id: "wax",
   section: "pse",
   projectStatus: "active",
   image: "wax.webp",
   name: "Wallet Account eXperiments - WAX",
-  tldr: "Streamlines web3 product development with smart account components for enhanced wallets, dApps, and SDKs.",
-  description,
   links: {
     github: "https://github.com/getwax",
     website: "https://wax.pse.dev/",
diff --git a/data/projects/zk-email.ts b/data/projects/zk-email.ts
index a1d79c39..2d61d93d 100644
--- a/data/projects/zk-email.ts
+++ b/data/projects/zk-email.ts
@@ -1,17 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-ZK Email is a library for anonymous verification of emails while selectively revealing specific data. It allows a prover to demonstrate receipt of an email from a specific sender or domain or the presence of certain text in the subject or body. This can be used for Web 2.0 interoperability, email recovery solutions of smart accounts, anonymous KYC, or to create interesting applications based on anonymity sets.
-`
-
 export const zkemail: ProjectInterface = {
   id: "zk-email",
   section: "collaboration",
   projectStatus: "active",
   image: "zk-email.jpeg",
   name: "zk-email",
-  tldr: "ZK Email is a library that allows for anonymous verification of email signatures while masking specific data.",
-  description,
   links: {
     github: "https://github.com/zkemail",
     twitter: "https://twitter.com/zkemail",
diff --git a/data/projects/zk-kit.ts b/data/projects/zk-kit.ts
index c38d8482..603932cc 100644
--- a/data/projects/zk-kit.ts
+++ b/data/projects/zk-kit.ts
@@ -5,9 +5,6 @@ export const ZKKit: ProjectInterface = {
   section: "pse",
   image: "zk-kit.svg",
   name: "ZK-Kit",
-  tldr: "A set of reusable libraries for zero-knowledge technologies.",
-  description:
-    "ZK-kit is a set of libraries (algorithms or utility functions) that can be reused in different projects and zero-knowledge protocols, making it easier for developers to access user-friendly, tested, and documented libraries.",
   projectStatus: "active",
   links: {
     website: "https://zkkit.pse.dev",
diff --git a/data/projects/zk3.ts b/data/projects/zk3.ts
index ef74b958..d7190c1f 100644
--- a/data/projects/zk3.ts
+++ b/data/projects/zk3.ts
@@ -1,17 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-Zk3 is a protocol that leverages Zero Knowledge Proofs (ZKPs) to allow users to prove their membership in a group without revealing their identity. This is particularly useful for social media applications built on Lens or other on-chain platforms. The protocol helps to moderate conversations and reduce bot activity while preserving user privacy. It provides developers with the tools to verify group eligibility, create ZK proofs, and use ZK proofs in Lens. ZK3 consists of a smart contract system for user interactions and network rules, and a GraphQL API for flexible interaction, enabling the development of diverse applications, including web 2.0 integrations.
-`
-
 export const zk3: ProjectInterface = {
   id: "zk3",
   section: "grant",
   projectStatus: "active",
   image: "zk3.svg",
   name: "zk3",
-  tldr: "Utilizing ZK proofs in social networks",
-  description,
   links: {
     github: "http://github.com/monemetrics/semaphore-zk3",
     website: "http://zk3.io/",
diff --git a/data/projects/zkevm-community.ts b/data/projects/zkevm-community.ts
index 68a0c9af..23135cf6 100644
--- a/data/projects/zkevm-community.ts
+++ b/data/projects/zkevm-community.ts
@@ -1,17 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-zkEVM Community Edition is a project aimed at validating Ethereum blocks using zero-knowledge proofs. It is designed to be fully compatible with Ethereum's EVM and serves two primary goals. First, it enables the creation of a layer 2 network (zkRollup) compatible with the Ethereum ecosystem, which uses zero-knowledge proofs to validate blocks, thus enhancing scalability. Second, it allows the generation of zero-knowledge proofs for blocks from the existing layer 1 Ethereum network, enabling light clients to quickly synchronize many blocks with low resource consumption while ensuring block correctness without needing trust in external parties.
-`
-
 export const zkevmCommunity: ProjectInterface = {
   id: "zkevm-community",
   section: "pse",
   projectStatus: "active",
   image: "zkevm.jpg",
   name: "zkEVM Community Edition",
-  tldr: "A zero-knowledge proof mechanism for Ethereum block verification.",
-  description,
   links: {
     github: "https://github.com/privacy-scaling-explorations/zkevm-circuits",
   },
diff --git a/data/projects/zkitter.ts b/data/projects/zkitter.ts
index b2d32c0a..6a5e14dd 100644
--- a/data/projects/zkitter.ts
+++ b/data/projects/zkitter.ts
@@ -1,17 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-Zkitter is a decentralized social network that emphasizes privacy by default. It allows users to share thoughts and communicate in various modes: as known identities, as a member of a group, or entirely anonymously. Built with Semaphore and RLN, Zkitter offers familiar social media features such as posting, chatting, following, and liking, but with a strong focus on user privacy and anonymity. It serves as an experiment to explore new ways of engaging in conversations without the fear of damaging one’s personal reputation and is an example of a user-facing application using zero-knowledge primitives such as Semaphore, CryptKeeper, ZK-Chat, and Interep. Users can sign up using an Ethereum address or ENS name, or create an anonymous account, with options for anonymous chat and posting.
-`
-
 export const zkitter: ProjectInterface = {
   id: "zkitter",
   section: "pse",
   projectStatus: "inactive",
   image: "zkitter.webp",
   name: "Zkitter",
-  tldr: "A decentralized social network prioritizing privacy and anonymity",
-  description,
   links: {
     github: "https://github.com/zkitter",
     website: "https://www.zkitter.com/explore/",
diff --git a/data/projects/zkml.ts b/data/projects/zkml.ts
index 133d6c75..0f4b3fb6 100644
--- a/data/projects/zkml.ts
+++ b/data/projects/zkml.ts
@@ -1,17 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-ZKML is a solution that combines the power of zero-knowledge proofs (ZKPs) and machine learning to address the privacy concerns in traditional machine learning. It provides a platform for machine learning developers to convert their TensorFlow Keras models into ZK-compatible versions, ensuring model privacy, data privacy, and transparent verification. ZKML can be used to verify if a specific machine learning model was used to generate a particular piece of content, without revealing the input or the model used. It has potential use cases in on-chain biometric authentication, private data marketplace, proprietary ML model sharing, and AIGC NFTs.
-`
-
 export const zkml: ProjectInterface = {
   id: "zkml",
   section: "pse",
   projectStatus: "active",
   image: "zkml.png",
   name: "ZKML",
-  tldr: "ZKML (Zero-Knowledge Machine Learning) leverages zero-knowledge proofs for privacy-preserving machine learning, enabling model and data privacy with transparent verification.",
-  description,
   links: {
     github: "https://github.com/socathie/circomlib-ml",
   },
diff --git a/data/projects/zkopru.ts b/data/projects/zkopru.ts
index f82744ce..3e775ac4 100644
--- a/data/projects/zkopru.ts
+++ b/data/projects/zkopru.ts
@@ -5,9 +5,6 @@ export const Zkopru: ProjectInterface = {
   section: "pse",
   image: "zkopru.svg",
   name: "ZKOPRU",
-  tldr: "Optimistic Rollup with zk-SNARKs for private Ethereum transactions.",
-  description:
-    "ZKOPRU is one of the initial projects of EF's PSE team. It is a Layer 2 scaling solution for Ethereum, emphasizing private transactions through zk-SNARKs and optimistic rollups. It provides an economical Ethereum privacy wallet, enabling users to transact with ETH, ERC-20s, and NFTs anonymously",
   projectStatus: "inactive",
   links: {
     website: "https://zkopru.network/",
diff --git a/data/projects/zkp2p.ts b/data/projects/zkp2p.ts
index 537eecc9..51158cb5 100644
--- a/data/projects/zkp2p.ts
+++ b/data/projects/zkp2p.ts
@@ -1,17 +1,11 @@
 import { ProjectInterface } from "@/lib/types"
 
-const description = `
-ZKP2P is for defi consumers looking to onramp assets on chain quickly without going through a CEX as an intermediary. ZKP2P generates a privacy-preserving proof of payment between two users on existing payment rails like Venmo or Paypal and uses said proof to unlock escrowed digital assets on-chain.
-`
-
 export const zkp2p: ProjectInterface = {
   id: "zkp2p",
   section: "grant",
   projectStatus: "active",
   image: "zkp2p.webp",
   name: "ZKP2P",
-  tldr: "Instant fiat to crypto onramp connecting traditional peer-to-peer payment services with zero-knowledge proofs.",
-  description,
   links: {
     github: "https://github.com/zkp2p",
     website: "https://zkp2p.xyz/",
diff --git a/hooks/useContent.ts b/hooks/useContent.ts
new file mode 100644
index 00000000..4bcbff51
--- /dev/null
+++ b/hooks/useContent.ts
@@ -0,0 +1,25 @@
+import { useEffect, useState } from "react"
+
+/**
+ * @dev This hook is used as helper to fetch content from the server
+ * @returns
+ */
+export default function useContent({ lang, id }: any) {
+  const [projectContent, setProjectContent] = useState<any>(null)
+
+  useEffect(() => {
+    const fetchContent = async () => {
+      const [content] = await Promise.all([
+        fetch(
+          `https://raw.githubusercontent.com/privacy-scaling-explorations/pse.dev/main/app/i18n/locales/${lang}/projects/${id}.json`
+        ).then((res) => res.json()),
+      ])
+      setProjectContent(content)
+    }
+    fetchContent()
+  }, [])
+
+  return {
+    projectContent,
+  }
+}
diff --git a/lib/types.ts b/lib/types.ts
index 074b3c5e..d666260b 100644
--- a/lib/types.ts
+++ b/lib/types.ts
@@ -79,8 +79,8 @@ export interface ProjectInterface {
   previousBrandImage?: string
   imageAlt?: string
   name: string
-  tldr: string // this is managed by the specific translation file
-  description: string // this is managed by the specific translation file
+  tldr?: string // this is managed by the specific translation file in /i18n/locales
+  description?: string // this is managed by the specific translation file /i18n/locales
   links?: ProjectLinkType
   projectStatus: ProjectStatusType
   tags?: ProjectTags