Friends, Kimi has updated again.
What's being released this time is Kimi K2.7 Code, which uses the same architecture as Kimi K2.6 and is a Coding-specialized version further trained based on Kimi K2.6.
From the official introduction, this upgrade is mainly in these aspects:
Reduced overthinking, with reasoning-token usage 30% lower than the previous generation Kimi K2.6, meaning faster responses and lower costs。
Benchmark tests have also improved significantly, and in the data published by Moonshot AI, Kimi K2.7 Code's performance in certain specific tasks has begun to approach GPT-5.5 and Opus 4.8.
I've also come across quite a few comparison reviews made by friends over the past two days. Under the same prompts, some physics animations and frontend pages generated by Kimi K2.7 Code even perform better than GPT-5.5 , and the actual cost is less than one-third of GPT-5.5.
The water ripple effect is very realistic.
Since it's a specially tuned version tailored for Coding and Agent scenarios, switching to this new model in daily programming tasks and agent workflows will undoubtedly be more suitable. And the official preview says,a 6x high-speed mode is also about to be launched。
Let's test and experience it together.
01. First-Hand Testing
Used in this review is Kimi Code + Kimi K2.7 Code, and it can also be used via the Kimi API.
SVG Image
Let's first try a relatively lightweight task.
Prompt: Please generate as detailed as possible the SVG code for a cute panda holding a hamburger with both hands.
At first glance, the visual aesthetics are on point. The panda's expression, the hamburger layers, the sesame seeds, the paw pads... these details are all fairly complete.
But looking closely, the panda's arms are not connected to its body, and the overall structural relationships still need optimization.
SVG Animation
After finishing the static SVG, let's look at the animation effect.
Prompt: Use SVG to draw an animation of the tortoise and the hare race.
The visuals are not bad, and it runs properly, but the heads of both the tortoise and the hare are facing the wrong direction, making it look like they are running backwards, and in the end the hare wins, which doesn't quite match the classic story.
Let's continue by having Kimi K2.7 Code try to fix it:
Prompt: Please fix the two problems in the current tortoise and hare race SVG animation:
- Wrong win/loss result
* Currently the hare wins, please change it to "the tortoise ultimately wins."
* It must conform to the classic tortoise and hare race logic: the hare is faster, but stops midway to sleep or rest; the tortoise is slower but keeps moving forward, and finally reaches the finish line first.
* Do not simply make the hare slower than the tortoise; the tortoise must overtake through the behavioral logic of "the hare resting / sleeping midway." 2. Wrong animal orientation
* Currently the movement direction of the tortoise and the hare is correct, both running from left to right toward the finish line; do not modify the movement path or the x-coordinate increment logic.
* The problem is that the animals' heads are facing the wrong direction; please only correct the characters' orientation so that both the tortoise's and the hare's heads face right, that is, facing the finish line.
* If scaleX(-1), transform, animateMotion, path, or grouped
<g> is used, please ensure that only the character's own visual orientation is adjusted, and do not reverse the direction of motion.
* It is forbidden for the animals to run backwards, run with their backs to the finish line, or have their bodies face left while their positions move right.
After fixing, please output the complete runnable code.
This case is very suitable for testing whether the model truly understands the process logic in the animation. If the model only changes the result, it can easily take the lazy approach of directly slowing down the rabbit.
Kimi K2.7 Code split the rabbit into three state phases: taking the lead at the start, stopping while sleeping, and sprinting after waking up, while the turtle kept moving forward at a constant speed, ultimately completing the overtake while the rabbit was sleeping.
This shows that the model is beginning to shift from result-oriented optimization toward process-level behavior modeling. It can satisfy constraints by constructing state changes in a time series, allowing the result to emerge naturally from the process, which conforms to a classic causal chain structure.
Complex front-end effects
Prompt: [Theme] Volcanic eruption
Goal: Build an interactive volcanic catastrophe scene where clicking the crater triggers an eruption.
Required features:
Click the crater area to trigger a volcanic eruption.
The eruption must include a lava column, spark particles, volcanic ash, and lava flows. It is forbidden to just draw simple flames.
At the moment of eruption, the sky and mountain body are illuminated by intense red-orange light, which then gradually fades.
A continuous volcanic ash particle system, where the dust needs to drift upward and be offset by the wind.
There needs to be a terrain silhouette at the bottom, which can be ridges, forest, village, or rocky wasteland.
Support continuous clicking. Multiple eruptions can overlap on the same screen and each fades independently.
Required visuals:
The main body of the lava is bright yellow/orange-red, with edges gradually darkening.
Spark particles need parabolic motion and a gradually extinguishing effect.
Lava flows need to slide slowly down the mountain slope and leave glowing trails.
Volcanic ash needs a sense of layering and cannot just be ordinary smoke dots.
Bonus items:
Lava ejection uses a particle system for simulation, with random perturbations in speed, direction, and size.
There are glowing cracks on the mountain surface; the stronger the eruption, the brighter the cracks.
The ground produces slight shaking or camera shake to simulate the explosive impact.
In the distant sky, volcanic ash clouds slowly spread.
When lava touches the ground, it produces smoke and a cooling darkening effect.
Eruption intensity escalates with click frequency: higher lava, more sparks, and thicker ash clouds.
Support gradual cooling and return to calm after a period without clicks.
Kimi K2.7 Code used pure native Canvas to implement the effects. Lava, sparks, volcanic ash, lava flows, smoke, and distant ash clouds were all created. Click frequency also affects eruption intensity, and intense light, cracks, and shaking were also implemented. Multiple eruptions are not independent events, the lava flow visuals are somewhat weak, and the logic chain closes quite well.
The downside is that the lava column is not sufficiently well-formed, and the presence of the lava flow is also relatively weak.
3D scene
Let's continue to increase the difficulty.
Prompt: [Theme] Magical forest cabin
Goal: Use HTML + JavaScript + Three.js to build a web-based 3D isometric scene: a little fox sitting at the entrance of a mushroom house, with a glowing magic lamp beside it.
Visual requirements:
The scene is in isometric view, with clear 3D spatial layering.
The little fox has a cute design and sits next to the mushroom house.
The mushroom house has a rounded roof, doors and windows, and fairy-tale-style details.
The magic lamp needs to glow semi-transparently and become the visual focal point of the image.
The ground includes grass, small flowers, stones, and a small number of firefly particles.
The lighting is soft, with ambient light, rim light, and local glow effects.
Materials should be distinct: fox fur, mushroom house, glass lampshade, grass, and stone should have different textures.
Technical requirements:
Output complete, runnable HTML code.
Use Three.js to implement the web 3D effect.
Do not use Blender, and do not rely on external image assets.
Try to build the scene using geometry, materials, lighting, and particles.
The code structure should be clear, including scene initialization, camera, lighting, model creation, particle effects, and the animation loop.
This type of task no longer mainly tests only whether one can write Three.js; it also depends on whether the model can simultaneously handle scene initialization, geometry composition, materials, lighting, particles, and the animation loop.
Kimi K2.7 Code can quickly build a complete scene structure, making it suitable for producing the first version of a 3D creative concept.
However, to truly turn it into a high-precision work, camera composition, model proportions, lighting layers, and material details still require manual fine-tuning.
Game
Prompt: Create a replica of Minecraft.
In less than five minutes, Kimi K2.7 Code replicated a simplified version of Minecraft. It not only completed terrain generation, but also implemented first-person perspective control, as well as block destruction and placement interaction, basically running through the core loop of a voxel sandbox.
UI Design
Prompt: Create a modern Apple-style login page.
Typography, dark texture, fixed frosted glass navigation, large headline text, buttons, and scroll animations are all present; at first glance it has an Apple official website feel.
The overall level of completion is already close in terms of style reproduction, but it is still not Apple-style enough in product credibility and information density control.
The device image on the first screen is just a gradient card, with no real device or interface as a visual anchor; although the glowing orb and SaaS cards make the image richer, they weaken the real product hero visual and restrained expression emphasized in Apple style.
BUG Detection and Fixing
This is where a programmer's hard skills are tested the most. I used a piece of code from the real open-source project File Browser for generating packaged file names to test Kimi.
Prompt:
Please conduct a security audit of the following real open-source project code and provide a production-ready fix.
Background:
The project is File Browser. The relevant feature is packaging files into zip/tar archives when a user downloads a folder. Please focus on checking whether the file name generation logic inside the archive has security risks.
Requirements:
Determine whether a vulnerability exists, and explain the vulnerability type and risk level.
Point out the specific code location where the vulnerability occurs.
Explain the cause of the vulnerability and the possible impact on different operating systems.
Provide a fix approach and key code patch.
Provide a pre-release testing plan, including unit testing, security testing, cross-platform testing, and regression testing.
Provide a production release plan, including version upgrades, canary release, log monitoring, user notification, and rollback plan.
The answer must be actionable and cannot just say "strengthen validation."
Code:
nameInArchive := strings.TrimPrefix(path, commonPath)
nameInArchive = strings.TrimPrefix(nameInArchive, string(filepath.Separator))
nameInArchive = filepath.ToSlash(nameInArchive)
Kimi K2.7 Code's answer is generally okay overall, but not excellent.
The identification of the vulnerability type is correct, and the risk point of Zip Slip was also caught; it knows that the problem is related to the archive filenames.
Kimi K2.7 Code uses filepath.Rel and filepath.Clean to normalize paths, adds checks for .. backtracking paths, blocks absolute paths, and unifies them into the / format used by zip/tar.
This shows that the model has begun to use path semantics to handle security issues and has developed a certain amount of engineering awareness.
It provided rollout plans such as testing, canary release, monitoring, and rollback. The engineering presentation is relatively complete.
The main problem is that Kimi K2.7 Code did not first establish a unified path normalization baseline, but instead made security judgments on multiple intermediate-state paths, resulting in the mixed use of the original path, Rel result, and Clean result, with inconsistent judgment semantics.
This fix is correct in direction, but it did not grasp the most critical issue of this real vulnerability: "Windows backslash cross-platform path semantics."
Landing page
Overall, it already captures the original design style at first glance. Key visual grammar such as the purple system, landscape illustration language, rounded card corners, and modular sections has basically been restored, so stylistic consistency holds.
The original purple has obvious warm-cool variation, with a gradual transition from light purple to deep purple. The replicated version leans more toward uniform tonal treatment, making it cleaner overall, but it also appears slightly more industrial and lacks a bit of breathing room.
Control of information density could also be more refined. At present, the rhythm of whitespace between modules is relatively even, making it visually more like regularized layout rather than a content flow with emphasis, pauses, and guidance; the sense of rise and fall along the reading path is not obvious enough.
How much did it cost to run all these tasks?
Finally, let's talk about the cost everyone cares about most.
This batch of cases covers SVG, Canvas, Three.js, games, security auditing, and long Next.js tasks. After running them all, I used only about 4% of my Kimi Code quota this week, which comes to about 6.99 yuan. For developers, the daily cost of trial and error is already low enough to be negligible.
02. Some sharing
Kimi K2.7 code is especially impressive on frontend and interaction tasks. For tasks like SVG, Canvas, Three.js, and mini-games, it can quickly build a complete version. For individual developers and tech bloggers, this ability to quickly validate ideas has extremely high practical value.
What is even more worth looking forward to is that next Monday, Kimi will launch 6x-speed Kimi K2.7 Code。
In conventional programming scenarios, the output speed is about 180 Token/s, and in short-context scenarios it can reach 260 Token/s.This will transform our development process from submitting requirements -> long waiting into extremely high-frequency real-time interaction。
The paradigm of our collaboration with AI is also becoming clearer: we are responsible for defining goals, checking results, and making final architectural judgments; AI is responsible for building frameworks, writing initial versions, and repeatedly revising, finishing a large amount of repetitive, mechanical work first.
AI is already very good at layout, color matching, and page structure, and the generated pages are usually clean and neat. But the problem is that they are too neat. Many times manual adjustment is still needed before a page goes from looking like a template to becoming a work with real design sense and detail.
Competition among open-source models has truly moved from chasing benchmark data to reducing costs and increasing efficiency in industry. As open-source models begin to trade wins and losses with top closed-source models on programming and Agent tasks, developers have unprecedentedly broad cards to play in architecture design, data security, and invocation cost.
Kimi K2.7 Code is just a microcosm of this wave. After the 6x-speed Kimi K2.7 Code goes live next Monday, can it get the job done both fast and reliably? We will wait and see.
Original link:Recreating Minecraft in under 5 minutes—just how capable is Kimi K2.7 Code?