AI Notes | Smart Note-Taking Application

One

$Note content$

Two Two

Four Piece

Linus Tech Tips has bought a private jet valued at around 5 million dollars. It was previously owned by the UAE government and has gold-plated sinks and ashtrays. Linus calls it a zero-dollar plane because of the recent expensive engine work and full service inspection that returned it to like-new condition.

New look at Earth.

(Source: Artemis II Crew)

# Next.js Guide

* Next.js App Router
* Tailwind v4
* React Hook Form + Zod
* Zustand
* React Query
* Radix UI

---

# 📁 Project Structure

```
src/
├── app/
│   ├── (auth)/login/
│   ├── (dashboard)/dashboard/
│   ├── api/
│   └── layout.tsx
│
├── features/
│   ├── auth/
│   ├── dashboard/
│   └── post/
│
├── entities/
│   ├── user/
│   └── post/
│
├── shared/
│   ├── ui/
│   ├── api/
│   ├── form/
│   ├── store/
│   └── lib/
```

---

# 🔐 Simple Auth Feature

## Structure

```
features/auth/login/
├── ui/LoginForm.tsx
├── api/login.ts
├── model/useLogin.ts
└── index.ts
```

## login API

```ts
export async function login(data) {
  return fetch('/api/login', {
    method: 'POST',
    body: JSON.stringify(data),
  }).then(res => res.json())
}
```

## Zustand Store

```ts
import { create } from 'zustand'

export const useAuthStore = create(set => ({
  user: null,
  setUser: (user) => set({ user })
}))
```

## Hook

```ts
import { useMutation } from '@tanstack/react-query'
import { login } from '../api/login'
import { useAuthStore } from '@/src/shared/store/useAuthStore'

export function useLogin() {
  const setUser = useAuthStore(s => s.setUser)

  return useMutation({
    mutationFn: login,
    onSuccess: (data) => setUser(data.user)
  })
}
```

## UI

```tsx
"use client"

import { useLogin } from '../model/useLogin'

export function LoginForm() {
  const { mutate } = useLogin()

  return (
    <form onSubmit={(e) => {
      e.preventDefault()
      mutate({ email: 'test@test.com', password: '123456' })
    }}>
      <button>Login</button>
    </form>
  )
}
```

---

# 🧾 Simple CRUD (Post Example)

## Structure

```
features/post/
├── create-post/
├── update-post/
├── delete-post/
```

---

## API

```ts
export async function getPosts() {
  return fetch('/api/posts').then(res => res.json())
}

export async function createPost(data) {
  return fetch('/api/posts', {
    method: 'POST',
    body: JSON.stringify(data)
  })
}
```

---

## React Query

```ts
import { useQuery, useMutation } from '@tanstack/react-query'

export function usePosts() {
  return useQuery({
    queryKey: ['posts'],
    queryFn: getPosts
  })
}

export function useCreatePost() {
  return useMutation({ mutationFn: createPost })
}
```

---

## UI Example

```tsx
"use client"

import { usePosts, useCreatePost } from '@/src/features/post'

export function PostList() {
  const { data } = usePosts()
  const { mutate } = useCreatePost()

  return (
    <div>
      <button onClick={() => mutate({ title: 'New Post' })}>
        Add
      </button>

      {data?.map(p => (
        <div key={p.id}>{p.title}</div>
      ))}
    </div>
  )
}
```

---

# 🎨 Tailwind v4

```css
@import "tailwindcss";

:root {
  --color-primary: oklch(0.6 0.2 250);
}
```

---

# 📦 Core Libraries (Standard)

These libraries are required in this architecture.

---

# 🧱 SHARED LAYER EXAMPLES (IMPORTANT)

This is the foundation used by all features.

---

## 🎨 shared/ui (Design System)

👉 Follow **shadcn-style (flat + pragmatic)**

### ✅ Recommended Structure

```
shared/ui/
├── button.tsx
├── input.tsx
├── badge.tsx
├── card.tsx
│
├── dialog/
│   ├── dialog.tsx
│   └── dialog-header.tsx
│
├── dropdown/
├── table/
```

---

### ✅ Simple Component (Flat)

```tsx
// shared/ui/button.tsx

export function Button({ className, ...props }) {
  return (
    <button
      className={`px-4 py-2 rounded-lg bg-black text-white ${className}`}
      {...props}
    />
  )
}
```

---

### ✅ Complex Component (Folder)

```bash
dialog/
├── dialog.tsx
├── dialog-header.tsx
```

---

### 🎯 Rules

* simple component → flat file
* complex component → folder
* always wrap Radix primitives here
* no business logic

---

---

## 🌐 shared/api (HTTP Client)

```
shared/api/http.ts
```

```ts
import axios from "axios"

export const http = axios.create({
  baseURL: "/api",
})
```

```
shared/api/fetcher.ts
```

```ts
export async function fetcher(url: string) {
  const res = await fetch(url)
  return res.json()
}
```

👉 Rule:

* no feature logic
* only base client

---

## 🧾 shared/form (RHF + Zod)

```
shared/form/useZodForm.ts
```

```ts
import { useForm } from "react-hook-form"
import { zodResolver } from "@hookform/resolvers/zod"

export function useZodForm(schema) {
  return useForm({ resolver: zodResolver(schema) })
}
```

👉 Used in features only

---

## 🧠 shared/store (Zustand)

```
shared/store/useUIStore.ts
```

```ts
import { create } from "zustand"

export const useUIStore = create(set => ({
  sidebarOpen: false,
  toggle: () => set(s => ({ sidebarOpen: !s.sidebarOpen }))
}))
```

👉 Use only for UI/global state

---

## 🧰 shared/lib (Utilities)

```
shared/lib/date.ts
```

```ts
import dayjs from "dayjs"

export function formatDate(date: string) {
  return dayjs(date).format("YYYY-MM-DD")
}
```

```
shared/lib/id.ts
```

```ts
import { v4 as uuidv4 } from "uuid"

export function generateId() {
  return uuidv4()
}
```

```
shared/lib/utils.ts
```

```ts
import debounce from "lodash/debounce"

export { debounce }
```

👉 Rule:

* small helpers only
* no domain logic

---

# 🧠 Rules

## ✅ DO

* feature = business logic
* entity = data
* shared = reusable
* app = routing only

## ❌ DON'T

* no services/ folder
* no global utils dump
* no logic inside app/

---

# 🧪 Mock API Strategy (Feature-Based Static Data)

✅ Use **feature-based static data + API per feature** (scalable)

---

## 📁 Structure (per feature)

```
features/post/
├── api/
│   ├── getPosts.ts
│   ├── createPost.ts
│   ├── updatePost.ts
│   └── deletePost.ts
│
├── mock/
│   └── posts.data.ts
```

---

## 🧾 Static Data

```ts
// features/post/mock/posts.data.ts

export let posts = [
  { id: 1, title: "First Post", createdAt: "2026-01-01" },
  { id: 2, title: "Second Post", createdAt: "2026-01-02" }
]
```

---

## 🌐 API (per feature - single module)

👉 Do NOT split per action (over-engineering)

```
features/post/api/posts.api.ts
```

```ts
import { posts } from "../mock/posts.data"
import { v4 as uuidv4 } from "uuid"

export const postsApi = {
  async getAll() {
    return Promise.resolve(posts)
  },

  async create(data) {
    const newPost = {
      id: uuidv4(),
      ...data
    }

    posts.push(newPost)
    return Promise.resolve(newPost)
  },

  async update(id, data) {
    const index = posts.findIndex(p => p.id === id)

    if (index !== -1) {
      posts[index] = { ...posts[index], ...data }
    }

    return Promise.resolve(posts[index])
  },

  async remove(id) {
    const index = posts.findIndex(p => p.id === id)

    if (index !== -1) {
      posts.splice(index, 1)
    }

    return Promise.resolve({ success: true })
  }
}
```

---

## 🔐 Auth Mock (same pattern)

```
features/auth/login/
├── api/login.ts
├── mock/user.data.ts
```

```ts
// features/auth/login/mock/user.data.ts
export const mockUser = {
  id: 1,
  email: "admin@test.com"
}
```

```ts
// features/auth/login/api/login.ts
import { mockUser } from "../mock/user.data"

export async function login(data) {
  return Promise.resolve({ user: mockUser })
}
```

---

## ✅ Why this is BEST

* scalable per feature
* no global coupling
* easy to replace with real API later
* matches real backend structure

---

# 🚀 Summary

This architecture gives:

* Clean separation
* Scalable structure
* Easy onboarding
* Production-ready setup

---

✅ You can share this with your team as a base standard.

A US fighter jet has been shot down over Iran, three US sources said, confirming Iranian state media reports.

US President Donald Trump has been briefed on the matter, White House press secretary Karoline Leavitt told CNN.

Here’s what we know:

Iranian claims: Iranian state media on Friday released photos of what it claimed to be the wreckage of a US Air Force fighter jet downed by the Islamic Revolutionary Guard Corps (IRGC).

About the jet: The Iranian reports said the jet was a F-35 stealth fighter, but CNN analysis of images published suggests it was more likely to be an F-15.

Status of crew: US sources said that the jet was shot down over Iran, and potential rescue efforts appeared to be captured in social video geolocated by CNN. Iran has been unsuccessful in its search for the missing crew, Iranian state news media Tasnim agency said, adding that local traders in the southwestern Kohgiluyeh and Boyer-Ahmad Province were offering a reward of 10 billion tomans ($76,000) for anyone who finds the crew alive. An Iranian soccer player offered medals he won while playing for Persepolis FC as a reward too.

Where it happened: It wasn’t immediately clear where in Iran the jet went down. The US military and the White House have not commented on the situation or the status of the pilots.

WASHINGTON, April 3 (Reuters) - A U.S. fighter jet has been shot down over Iran and a search-and-rescue operation is underway for any survivors, two U.S. ​officials told Reuters on Friday, in the first such known incident since the war began nearly ‌five weeks ago.
The Pentagon and U.S. Central Command did not respond to requests for comment.
The Reuters Iran Briefing newsletter keeps you informed with the latest developments and analysis of the Iran war. Sign up here.
The prospect of U.S. pilots being alive and on the run inside Iran raises the stakes for the United States in a conflict that has struggled to win popular support ​among Americans, according to opinion polls.
Advertisement · Scroll to continue
It also presents a challenge to the U.S. military, which faces the ​twin goals of trying to save the lives of any surviving U.S. crew and safeguard ⁠whoever is involved in perilous rescue missions.
Iranian officials called on civilians to be on the lookout for survivors ​and have flooded social media with images that purport to show wreckage from the aircraft.
One of the U.S. officials said ​the aircraft was an F-15 fighter jet.
William Goodhind, a forensic imagery analyst with Contested Ground, said images of the plane's tail fin seen in photos posted on social media are consistent with that of an F-15E Strike Eagle, which carries two crew.
Advertisement · Scroll to continue

Skip to content
Engineering at Meta
Search this site
Open Source 
Platforms 
Infrastructure Systems 
Physical Infrastructure 
Video Engineering & AR/VR 
Artificial Intelligence 
Watch Videos
POSTED ON MARCH 30, 2026 TO Data Center Engineering, ML Applications, Open Source
AI for American-Produced Cement and Concrete

By Julius Kusuma, Sebastian Ament, Eytan Bakshy, Laura McGorman, Madeline Hinkamp



Meta is continuing its long-term roadmap to help the construction industry leverage AI to produce high-quality and more sustainable concrete mixes, as well as those exclusively produced in the United States. 
Concurrent with the 2026 American Concrete Institute (ACI) Spring Convention, Meta is releasing a new AI model for designing concrete mixes – Bayesian Optimization for Concrete (BOxCrete), as well as the foundational data used to develop award-winning concrete mixes.
Meta’s open source model for sustainable concrete is available today on GitHub.
Every year, the United States pours roughly 400 million cubic yards of concrete, enough concrete to pave a two-lane highway that circles the Earth multiple times. It’s the backbone of our bridges, data centers, highways, and homes. However, while we produce most of our ready-mix concrete domestically, we import nearly a quarter of the cement that makes it. Meta’s AI is helping change that. 

Concrete consists of a mix of cement and cementitious materials, aggregates, water, and chemical admixtures. Concrete suppliers have to design concrete mixes to meet competing requirements: strength, speed, ease of handling, cost, and sustainability. Traditional concrete mix design relies heavily on trial-and-error in the lab, engineer intuition, and decades of accumulated knowledge—a workflow that is slow and expensive to adapt.  

Cement is a key element of concrete, thus imported cement can have a significant impact on U.S. suppliers, stifling U.S. manufacturing, jobs and investments. While ready-mix concrete is typically produced domestically, the cement required for it is heavily imported, with roughly 20-25% of U.S. cement consumption met by imports. Additionally, cement made in the U.S. complies with U.S. performance and environmental standards that are not consistent internationally. 

At the same time, ensuring products are produced domestically—a process often called reshoring — generally increases manufacturing jobs in the United States. Reshoring and related foreign direct investment (FDI) have brought over 1.1 million jobs back to the U.S. since 2020, and manufacturing has one of the highest economic multipliers; with every $1.00 spent in manufacturing adding $2.69 to the U.S. economy. The cement and concrete sector alone contributes more than $130 billion annually and supports roughly 600,000 jobs — yet imports still supply about 23% of total domestic demand. To capture more of that value at home, U.S.-based concrete producers want to incorporate more U.S.-made materials in their mixes.

Different cements have different chemistries, and a mix that works perfectly with one cement might fail entirely with another. As a result, producers need a way to rapidly explore and validate new formulations without spending months in the lab.

Real-World Impact Across the U.S.
Meta and its partners have already received a number of awards for these innovations in concrete design, including a 2025 Building Innovation Award for Best Partnership (shared with Amrize) and a Slag Cement Award in 2025 for Sustainable Concrete Project of the Year (shared with Amrize and the University of Illinois at Urbana-Champaign). But the impact of this model is also being felt through on-the-ground collaborations in several states through partnerships with large-scale concrete manufacturers and software companies.

Illinois
Meta has been partnering closely with the University of Illinois at Urbana-Champaign and Amrize, the largest cement and concrete manufacturer in North America, headquartered in Chicago, IL., on the implementation of AI for sustainable and domestically-produced concrete. Amrize operates 18 cement plants, 141 cement terminals and 269 ready-mix concrete sites  across North America. Their scale makes them an ideal partner for demonstrating how AI can transform mix design at industrial volumes. Amrize recently launched a Made in America cement label, which guarantees the cement meets rigorous U.S. standards and was manufactured in the U.S. by a domestic workforce with American materials. The company also recently announced close to $1 billion of capital investments in 2026 in part to increase domestic cement production.  

Meta and Amrize will be presenting at the American Concrete Institute (ACI) Spring Convention, along with researchers from the University of Illinois Urbana-Champaign to further showcase our partnership leveraging AI for lower-emission, domestically-produced concrete.

Alongside the event, Meta is releasing a new AI model for designing concrete mixes, Bayesian Optimization for Concrete (BOxCrete). BOxCrete improves over Meta’s previous models with more robustness to noisy data as well as new features including the ability to predict concrete slump (an important indicator of concrete workability).

Coupled with BOxCrete, Meta is releasing the foundational data used to develop the novel concrete mix used in our Rosemount, MN data center. This foundational data is the best systematic foundational data for concrete mix performance compared to other open-sourced, published datasets. 

Meta’s researchers have submitted a paper on BOxCrete for publication that outlines the new model, data, and the associated methodology.

Minnesota
In partnership with Amrize, Mortenson and the University of Illinois at Urbana-Champaign, BOxCrete was used to generate a stronger, faster-curing concrete mix that was used at scale in a site support section in one of our data center building slabs in Rosemount, MN. 

The AI-optimized mix was designed for one of the most demanding parts of the build: the massive concrete foundation that supports the weight of thousands of servers and cooling systems. Using domestically sourced materials, the mix reached full structural strength 43% faster than the original formula, while also reducing cracking risk by nearly 10% — proving that AI can help American producers rapidly reformulate around U.S.-made materials without sacrificing quality. With the data confirming it meets all structural requirements, the mix is now qualified for use in additional areas of the data center.


Meta’s data center in Rosemount, MN.

Pennsylvania
In 2023, Meta released its concrete optimization AI framework as open-source software under the MIT license, enabling broad adoption from academia to commercial software providers.

In an effort that reflects how AI-driven mix design is becoming part of the standard infrastructure of concrete production, Pennsylvania-based Quadrel, a leading enterprise SaaS platform serving the ready-mix industry, has adapted Meta’s AI framework in its software. Quadrel has applied it to real-world use cases including data preprocessing, batch and test normalization, feature engineering, and customer-specific model training. The models, which continuously improve over time as field test results are incorporated, have been embedded into daily mix design and quality control workflows, informing day-to-day decisions in quality control and operations.


Meta’s open-source AI model for sustainable concrete is provided under MIT license, allowing for commercial use with minimum restrictions while benefiting from open-source AI advances and investments.

How Meta Leverages AI for Concrete Mixtures
Meta’s AI for concrete model can help suppliers more quickly incorporate U.S. materials into their mixes through an approach called adaptive experimentation. 

Here’s how it works: 

Meta’s Adaptive Experimentation (Ax) platform uses Bayesian optimization to intelligently navigate the vast space of possible concrete formulations. Instead of testing mixes randomly or relying solely on human intuition, the AI: 

Learns from existing data: Historical mix designs, lab results, and performance metrics train the model on what works
Proposes high-potential candidates: The AI suggests new mixes most likely to meet target specifications and can compare performance between U.S.-made and foreign materials
Incorporates constraints upfront: Users specify technical requirements and the ingredients to be used.
Refines with each test: Every lab result improves the model’s predictions, giving rise to an automatic improvement loop. 
While the inclusion of AI and adaptive experimentation does not change the process of lab validation, field trials, engineering sign-off, and code compliance, it greatly improves the speed of discovery, helping engineers find better starting points with fewer tests.



 

		
Source: University of Illinois at Urbana-Champaign
Building an AI-Assisted Future for Concrete 
Meta’s AI for concrete is part of a broader commitment to applying machine learning where it can drive measurable, real-world impact. While the work with Amrize, the University of Illinois, and industry software providers like Quadrel represents the first wave of adoption, the goal is an industry-wide shift in how American producers approach mix design.

Over the next few years, Meta is planning to further collaborate with the construction industry to develop new AI tools. As more platforms like Quadrel build on BOxCrete, AI-optimized mix design becomes accessible to producers without requiring them to change their existing workflows. The team is also planning on continued academic collaboration with the University of Illinois Urbana-Champaign to explore how AI can address not just domestic material substitution, but broader challenges in concrete sustainability and performance.

By reducing the barriers to domestic material adoption, Meta is helping American producers compete on cost, reduce emissions, and build supply chain resilience, one mix at a time.

Get Involved
Explore Meta’s open-source BOxCrete for Sustainable Concrete on GitHub.

Read our pre-print: “BOxCrete: A Bayesian Optimization Open-Source AI Model for Concrete Strength Forecasting and Mix Optimization.”

Share this:
 Facebook Threads WhatsApp LinkedIn Reddit X Bluesky MastodonHacker News Email

Friend Bubbles: Enhancing Social Discovery on Facebook Reels
Prev
Friend Bubbles: Enhancing Social Discovery on Facebook Reels
Meta Adaptive Ranking Model: Bending the Inference Scaling Curve to Serve LLM-Scale Models for Ads
Next
Meta Adaptive Ranking Model: Bending the Inference Scaling Curve to Serve LLM-Scale Models for Ads
Read More in Data Center Engineering
View All 

FEB 24, 2026
RCCLX: Innovating GPU Communications on AMD Platforms

FEB 9, 2026
Building Prometheus: How Backend Aggregation Enables Gigawatt-Scale AI Clusters

NOV 21, 2025
Zoomer: Powering AI Performance at Meta’s Scale Through Intelligent Debugging and Optimization

NOV 14, 2025
Open Source Is Good for the Environment

OCT 20, 2025
Disaggregated Scheduled Fabric: Scaling Meta’s AI Journey

OCT 16, 2025
10X Backbone: How Meta Is Scaling Backbone Connectivity for AI
Related Posts

Jul 16, 2025
Using AI to make lower-carbon, faster-curing concrete

Nov 18, 2025
Efficient Optimization With Ax, an Open Platform for Adaptive Experimentation

Nov 14, 2025
Open Source Is Good for the Environment
Related Positions
NPI Program Manager
FREMONT, US
Strategic Supply Chain Risk and Resilience Lead
BELLEVUE, US
Strategic Supply Chain Risk and Resilience Lead
FREMONT, US
Software Engineer, Systems ML - SW/HW Co-design
SUNNYVALE, US
Software Engineer, Systems ML - SW/HW Co-design
BELLEVUE, US
Available Positions
NPI Program Manager
FREMONT, US
Strategic Supply Chain Risk and Resilience Lead
BELLEVUE, US
Strategic Supply Chain Risk and Resilience Lead
FREMONT, US
Software Engineer, Systems ML - SW/HW Co-design
SUNNYVALE, US
Software Engineer, Systems ML - SW/HW Co-design
BELLEVUE, US
Technology at Meta
footer-fb-engineering
Engineering at Meta - X
footer-AI
AI at Meta
footer-developers
Meta Quest Blog
footer-developers
Meta for Developers
footer-bug-bounty
Meta Bug Bounty
footer-rss
RSS
Open Source
Meta believes in building community through open source technology. Explore our latest projects in Artificial Intelligence, Data Infrastructure, Development Tools, Front End, Languages, Platforms, Security, Virtual Reality, and more.

android
ANDROID
ios
iOS
web
WEB
backend
BACKEND
hardware
HARDWARE
Meta
Engineering at Meta is a technical news resource for engineers interested in how we solve large-scale technical challenges at Meta.

Home
Company Info
Careers
© 2026 Meta
Terms
Privacy
Cookies
Help
To help personalize content, tailor and measure ads and provide a safer experience, we use cookies. By clicking or navigating the site, you agree to allow our collection of information on and off Facebook through cookies. Learn more, including about available controls: Cookie Policy

Accept