A separate app for every job in the fab.
Dispatch, carriers, recipes, planning, quality, maintenance, the ERP link: each its own system, its own sign-in, its own interface layer and its own cron jobs. OpenCore MES is one platform for all of them, with one integration layer.
A fab today: an MES and its satellites.
Every app bought beside the MES brings its own glue: a message bus here, a file drop there, a database link, a stored procedure, an export, and a job on a clock to move each. Jobs and triggers run inside the MES database, and scripts nobody wrote down keep it all together. Then the apps are wired to each other too.
One core, every fab app wired into it.
Each suite plugs into the same core. Events from tools, carriers from the MCS and orders from the ERP stream in; dispatch lists, transfers and confirmations stream out.
A small fab starts with all of it.
A 150 or 200 mm line runs on paper, spreadsheets and a few connected tools. Start on day one with what a large fab ends up with after buying a dozen apps or more, and grow into it a step at a time.
- Your wafer size, your carriers. Lots, wafers and carriers are designs: 150 or 200 mm, open cassettes or FOUPs.
- Manual steps on a tablet. The same transactions and signatures at the bench as on a connected tool.
- Out of spreadsheets. Your Excel workbooks imported into your models.
- Tools one at a time. Connect a tool over HSMS when you are ready; the rest keep running by hand.
- Suites when you need them. Dispatch, material handling and planning added later, on the same core.
- Older tools over SECS-I (serial), beside HSMS.
One integration layer, not one per app.
Every app a fab buys brings its own interfaces and its own jobs on a clock. Here there is one of each, for everything.
A fab today
An integration project for every app.
- Each app with its own interface layer, and middleware between them
- Cron jobs on each app's server, each with its own failures
- A failed transfer found in whichever app's log holds it
- Every upgrade of one app retests its interfaces to the others
OpenCore MES
One layer every suite builds on.
- Connections and services, in and out, each approved like any design
- Schedules as designs, not cron: written in words, run once however many servers there are
- One outbox: retried by itself, sent again from one place
- One monitor for every run in and out, with the line that failed
- Suites build on it: ERP integration, material handling, dispatch and fab planning are designs, with no middleware or schedules of their own
Gateway suites for every connection.
What speaks to the world outside comes as a gateway suite, and everything it brings in goes through the same checks and audit trail as a person's work.
- Equipment integration. Tools over SECS/GEM (HSMS), GEM300, OPC UA and MQTT.
- Import & Export. Any CSV or Excel file, an ERP's export or a supplier's list, mapped onto your models.
- Other OpenCore MES sites, in the core. Their services discovered and mapped to yours, without code.
- Any system over HTTP, in the core. Web services, transactions and queries, described by OpenAPI.
- A database gateway, straight to an ERP's database.
One app, not a dozen.
What every suite shares, because it is the core's, not the suite's.
- One sign-in, one directory. The same people, departments and roles in every suite.
- One way to change anything. Design, review, approval, execution and verification, whichever suite it belongs to.
- One audit trail. A dispatch decision, a carrier move and an ERP confirmation, kept the same way.
- Live, not overnight. Screens update as records change; tool events become states as they happen.
- One monitor. Every schedule, trigger and call in or out, with why it failed.
- One copilot. It knows every installed suite and drafts across all of them.
- Taken in as one change. A suite's designs arrive from its pack, tried in a sandbox, then approved.
- Removable. Take a suite away and the core runs on; its data waits for it.
- One instance or several. Each runs the suites it needs; linked by approved designs, they work as one plant.
- A space per team. Each team designs in a space of its own; everyone reads every design, and a team changes only its own.
The fab's apps, as suites.
Front end and back end, the floor and the office around it.
- Equipment integration. SECS/GEM, GEM300 carriers and jobs, OPC UA and MQTT; each tool's events into its states as they happen.
- Wafer fab. Lots in FOUPs through a 300 mm route; recipes checked at track in, reticles, SPC with its out-of-control plan, WAT.
- Real-time dispatch. The next lot for each tool as a score a person can read: priority, due date, queue time, setup, batch, WIP; the decision kept. New.
- Material handling. Where every carrier is and how it got there; transfers asked of your MCS and followed to delivery. New.
- Fab planning. Wafer starts worked down each route into tool hours, capacity by tool group, cycle time and WIP targets. New.
- ERP integration. Production orders in, with their items, bills and routings; confirmations and goods movements out. New.
- Semiconductor and load boards. Back-end assembly and test; the test floor's crib, PM by touchdowns.
- Quality, maintenance, materials, vendors, OEE, shifts. The plant's own apps, on the same core.
- Statistical process control and sampling. Limits worked out from data and approved, Western Electric and Nelson rules, the out-of-control plan, skip-lot sampling. New.
- Run-to-run control. A recipe's offset moved from metrology, only inside limits approved with the recipe. New.
- Equipment data and fault detection. Samples stay in your historian; each run's summary kept with the hash of its window, faults acted on, affected lots held. New.
- Yield and wafer maps. Die-level bin maps per wafer, defect scans (KLARF), the lot rolled up, an excursion plan. New.
- Document control and training. SOPs by revision, signed and made effective on their date, read and understood, training records, retraining when a revision asks. New.
- Wafer manufacturing: crystal to polished wafer, 200 and 300 mm. Planned.