The Sun MAJC (Microprocessor Architecture for Java Computing) was a VLIW CPU architecture designed by Sun Microsystems in the late 1990s. Its original intent was to create a hyper-optimized platform for running Java applications. Indeed, its original trade name was to be UltraJava, to pair nicely with the more general-purpose UltraSPARC. It was based around a very long instruction word architecture, which moves the complexity from the on-chip scheduler to the compiler, allowing the chip itself to focus more on the entire workload and not so much on a single running process or thread. It also used chip multithreading, known in the PC world as Hyperthreading. Unlike Intel's implementation, the MAJC's SMT was a designed-in feature rather than an afterthought. It had a rotating register set that allowed it to instantly 'swap in' another thread in the event of a pipeline stall.
Unlike other VLIW processors like the Itanium or the Transmeta Crusoe, the MAJC used a variable-length instruction word. Most VLIW designs require segments of the instruction word in which no instructions can be scheduled, to be padded with NOP (no operation) instructions, which simply waste space. MAJC instead allows the compiler to simply emit shorter instruction words in this case. This allows the cache to hold a larger working set of code, reducing expensive cache misses. This comes at the cost of slightly increased complexity in hardware, however. It also did speculative prefetches for non-running threads, aiming to minimize the impact of cache misses as much as possible. Further, its functional units were general-purpose, rather than being designed only for integer, floating point or SIMD operations. This allowed all functional units to be executing something on every clock cycle. The FUs themselves ran somewhat more slowly than those of a traditional CPU like x86 or SPARC, but unlike in those, no execution units would sit idle just because the workload at the time happened to be very heavy in one area, but not in others. (This is commonly the case for compilation, for example, which uses lots of integer math but rather little FP and almost no SIMD.)
Ultimately, the market for Java-only machines failed to materialize, and like the other experiment in this direction, the JavaStation, MAJC never found a commercial niche. Sun did make use of it, however. They produced a single model, the MAJC 5200. This was a dual-core chip running at 500MHz, one of the first mass-produced dual-core chips. It was used as the GPU in the XVR-1000 and XVR-4000 graphics cards. The ideas behind the MAJC chip didn't fully die here, though - the idea of chip multithreading rematerialized in the UltraSPARC T1, codenamed Niagara, which can hold the state of up to 4 threads per core. Current US-T1 designs have 8 cores, and thus can juggle up to 32 threads, with 8 actually running at once.