AI 编程火了这么久，无论是开发者还是我们普通人，都能让 AI 来帮忙做个小游戏、捣鼓点小工具。

有时候还真别说，那些 AI 做的小玩意，的确能起到点作用。很多读者也经常在留言区评论，现在最好的编程模型是什么？

Claude 4.5 + Cursor 自一直是很多开发者的首选，但它们由于种种原因对中国用户都不太友好，结果是花同样的钱开会员，有可能很多模型都用不了。

好消息，这次我们不会被「卡脖子」了。

昨天，字节发布了他们的编程工具，TRAE 3.0，我们体验了一下，在某种程度上，TRAE 可以说就是一个国产版 Cursor，甚至部分功能做得比 Cursor 还要好。

其中，最核心的功能 SOLO 模式，是之前所有同类产品，没有探索过的 AI 编程工具形态。它提供了 SOLO Coder 和 SOLO Builder 两个智能体，一个针对专业的开发者用户，处理复杂的项目开发问题；一个针对个人和小团队，真正做到一句话做个产品，能上线发布的产品。

这两个 SOLO 智能体，把过去传统软件开发，涉及到的全部工作基本都包揽了。目前 SOLO 模式正在限免期，前往 trae.ai 下载安装，登录之后就能免费体验到 15 号。

限免期之后，TRAE 的会员计划也比 Cursor 更良心，首月是 3 美元，次月开始 10 美元。和免费用户的区别就是在模型调用、快速响应上的额度分配不同。

SOLO 模式，让编程更加 Vibe

SOLO 模式其实最早是在 TRAE 2.0 的时候推出的，当时只是用来快速生成一个应用。而更新的 TRAE 3.0 版本中，是把快速生成的应用，能做得更复杂，还给专业开发者带来了更高效的功能。

之前，我们使用大多数的编程产品，或者就是要 ChatGPT、Gemini 这些通用助手，来进行 vibe coding。

本质上还是，我们单纯地跟模型进行对话，解决某一个具体的问题，最后的产出也比较有限，一般就是一个我们看都看不懂的代码文件，点个预览就够了。

但现在，TRAE SOLO 模式改变了过去传统的开发工具、或者 AI 聊天编程产品的形态。它整体的布局更像一个大模型助手的智能体界面，没有了中间的代码编辑器，最左边也不是文件管理器，而变成了任务列表。

SOLO Coder：面向复杂项目开发

TRAE 提供了 Coder 和 Builder 两个选项，SOLO Coder 主要是针对复杂的项目开发，更专业的应用场景。一般是我们有现成的项目，可以通过 Coder 来完成一些项目迭代、Bug 修复和架构重构等。

我们选择了一个 GitHub 上的开源项目，动辄上千上万行的代码，根本看不懂。然后直接问他有没有什么更好的网络结构等组件，可以让这个方法的效果更好。

前几天我刷社交媒体，看到有人在问，大家在 vibe coding 等结果的过程中一般做什么。

有人说真正的 Vibe 是应该打开手机开始刷视频，也有人说会盯着 AI 的每一步操作，防止它莫名其妙删库跑路，还有说再开一个 Agent 来执行其他任务。

SOLO 模式似乎也考虑到了这一点，在任务处理过程中，是可以多任务并行的，意思是我们可以同时执行多个项目。同时，SOLO 智能体在调用不同的工具过程中，会可视化全部的工具调用流程、自动切换不同的工具面板，TRAE 把这一点叫做「实时跟随」。

和 TRAE 2.0 会显示当前使用的模型不同，在 Claude 彻底断供之后，TRAE 3.0 在 SOLO 模式下，只会显示 Max 模型，且不能自定义选择模型。

SOLO Builder：从零构建一个应用

SOLO Coder 还是有点太专业了。另一个智能体，SOLO Builder 在某种程度上，则是一款很典型的 vibe coding 产品，和我们之前分享过的 Lovable 一样，它主打的是从零开始，一句话构建一个产品。

但不同的是，SOLO Builder 能凭借 TRAE 自身强大的开发环境，真正做出一个大规模可用的产品，不会停留在做一个小玩意路线上。

一款应用从构思到最后真正上架到 App Store，中间要完成的需求分析、UI 设计、系统环境等等，都可以在 SOLO Builder 中，通过 AI 来完成。TRAE 提供了包括编辑器、文档、终端、浏览器、Figma、智能体、MCP在内的多个工具。

通过调用不同的工具，仿佛真的有一个助手在操作我们的电脑：在写清楚产品需求文档后，默默地又开始写代码来实现，最后再自己测试代码、部署整个项目；把产品经理、程序员、测试、运维的活全干了。

我们输入了一个需求，是让它做一个摸鱼 APP。得到了对应的文档之后，SOLO Builder 不会立刻执行，而是让我们先确认这个计划是否可行。此刻我们就是项目经理，告诉 AI 来 Align（对齐）一下颗粒度，不行就要 AI 再回去修改文档。

在 SOLO Coder 智能体，同样有「Plan 计划」的开关，先让模型规划怎么做，我们再确认。

一切顺利，我们得到了最后的摸鱼 App，TRAE 还贴心的提供了一个推荐操作，让我们把项目部署到 Vercel（托管网站的平台）上，而不仅仅是本地访问。

不过，SOLO 模式目前还只在国际版推出，国内版本可以通过加入候补名单，等待上线。

豆包编程模型，TRAE 的国产版核心

虽然国内版本还没有 SOLO 模式，但是字节最新的豆包编程模型，已经在 TRAE 国内版上线了。

Doubao-Seed-Code 是字节这周二发布的一款全新模型，它专门在 Agentic 智能方面，进行了深度优化；在多个编程相关的基准测试中，表现结果全面领先国产的同类模型；此外，它的输入输出还做到了国产模型的最低价。

用直观的例子说明，在相同 Tokens 数量的任务下（0-32k 输入区间），Claude Sonnet 4.5 完成需要约 4.05 元，GLM-4.6 要 0.77 元，而 Doubao-Seed-Code 的成本是 0.34 元。

Doubao-Seed-Code 的亮点还包括，它支持最高 256K 的上下文长度，能应付一般的长代码文件。它也是国内第一个支持视觉理解能力的编程模型；通俗点讲，就是不用自己口头描述做什么，一张设计稿、截图，就能自动生成对应的内容。

模型提供的 API 调用，支持在 Claude Code 中使用，也对字节跳动自家的编程开发工具 TRAE，Cursor、Codex CLI、Cline 等主流的开发生态，实现了全面的兼容。

目前，Doubao-Seed-Code 可以在火山方舟大模型体验中心、TRAE 中国版直接使用，也可以透过平台的 API 调用。

在 TRAE 中国版，还提供了 Kimi K2，GLM 4.6，以及 DeepSeek、Qwen 等常见国产编程模型。

我们也在火山引擎官网、TRAE 、以及 API 调用几种方式里，体验了这款全新的编程模型，不能说吊打 Claude，但是配合自身的编程开发环境、和超低的费用，很难不让人心动。

模型能力实测，一张草图生成一个项目

视觉理解是 Doubao-Seed-Code 的一大亮点，但其实从图片复制网页，甚至是在 AI 大语言模型流行之前，就已经有类似的应用。而多模态的能力，现在也基本上成为了每个模型的标配。

我们从网上找了一张手绘的网页布局图片，直接让它根据这张草图，生成对应的前端页面。

还原度还是很高的，复制代码拿过来直接用作自己的项目，或者再要它添加一些处理的逻辑，神笔马良的即视感。

除了这种照搬图片的内容，我们还找了一张大家熟知的游戏截图，Flappy Bird，但是截图里面就是几根柱子。上传截图并提问，你认识这个游戏吗？用一个单页的 HTML 实现它。

虽然简陋了一点，但是 Douban-Seed-Code 在深度思考的过程，一眼就看出来这是 Flappy Bird 的游戏。最后的实现，把小鸟直接换成了一个原点，但确实是一张图就能生成游戏。

火山方舟的模型体验中心更多是一种 Playground 的存在；Doubao-Seed-Code 的发布，直指当下火热的 AI 编程赛道。

字节也专门为 Doubao-Seed-Code 在 TRAE 中的表现进行过优化，与 TRAE 深度结合的豆包编程模型，在对应的编程基准测试中，甚至拿到了超过 Claude 4.5 Sonnet 的成绩。

和网页版处理不同，在本地使用，意味着我们的主动权更大。我们直接把过去几篇 APPSO 的文章放到项目文件夹，然后在 TRAE 里和模型对话，要它根据这些文件，帮我制作个人作品集。

在豆包编程模型的介绍资料里，我们看到字节用了一套大规模的 AI 强化学习系统，来完成智能体的学习训练。

• 覆盖十万个不同环境的数据集，让 AI 见识各种复杂任务。
• 不需要老师手把手的教，而是完全依靠端到端的强化学习，模型自己总结经验。

在 TRAE 中运行了一会儿了，就得到了最后的个人作品集网页，说实话总结得很不错，在精选文章那一部分，都是 AI 自动帮我配的图片。

除了直接使用，豆包编程模型还提供了 API 的方式，能够配置到 Claude Code 之类的工具中。

我们之前在介绍 Google 全家桶时，分享过 Gemini CLI（和 Claude Code 类似的命令行终端工具）的使用体验，基本上能减去我们找各种第三方工具的繁琐。

在火山引擎的官网，字节更是直接给出了完整的将 Doubao-Seed-Code 配置到 Claude Code 的详细步骤，我们只需要照着教程走，就能得到一个不会被断供的 Claude Code。

简单配置之后，我们就可以进入到 Claude Code 的页面，并且显示当前的模型时 doubao-sseed-code-preview-251028。

字节这波发 Cursor 平替 SOLO 模式，又发 Claude 4.5 平替 Doubao-Seed-Code，能看出来是真的很想把 AI 编程做到极致，毕竟这是现在的大热门。

有多热，代表性产品 Cursor 在最新一轮融资后，估值来到了 300 亿美元，并且它几乎可以确认，将是历史上最快达到 10 亿美元 ARR 的公司。

而前些天，柯林斯词典也宣布，把 Vibe Coding 作为 2025 年度词汇；这一年来，无论是不是学计算机专业的，多多少少都已经接触到了 AI 编程。

简单的「帮我生成一个贪吃蛇的游戏」、到复杂的大型项目管理，代码完全变成了向 AI，而更少面向开发者的语言。

这种趋势也在大多数的基础模型，把编程能力作为主要卖点的背景下，变得越来越流行。如果在去年问一个 AI 编程的用户，他会选择什么模型，毫不犹豫地说，一定是 Claude 3.5。

到了今年这个时候，Claude 断供看起来反而是倒逼了我们一把。国产的编程模型有了智谱的 GLM 4.6、阿里的 Qwen Coder、Minimax M2、月之暗面的 Kimi K2 Thinking，个个都榜上有名；今天又多了一个选择，Doubao-Seed-Code。

模型之外，工具的演变也没停下来，从只是生成代码然后预览，到现在 TRAE 要把软件开发一条龙全面服务到位。即便现在说 AI 编程，要全面取代程序员还不太可能，但让 AI 手搓一个微信，未来三五年说不定真的能做到。

#欢迎关注爱范儿官方微信公众号：爱范儿（微信号：ifanr），更多精彩内容第一时间为您奉上。

爱范儿 | 原文链接 · 查看评论 · 新浪微博

If you’ve left plates coated with egg for a while, you’ll know how difficult its residue can be to remove. No one knows when people first took advantage of this in paints, but earliest surviving examples date from late classical times. By the Renaissance, egg yolk was popular as a binder in artists’ paints, and the technique of egg tempera was used to create many of the masterpieces of the day.

Pure egg tempera technique uses the proteins, fats and other constituents of the yolk of fresh hens’ eggs as its binder; being water-based, water is its diluent. Applied thinly to an absorbent ground such as powdered chalk in a gesso, this quickly sets to form a hard if not brittle paint layer which, unlike glue tempera, can’t readily be removed by water.

Because egg tempera forms such a hard paint layer but is applied thinly, it’s prone to cracking unless the support is rigid and doesn’t change dimensions over time. Early egg tempera paintings were almost exclusively made on wood, but more recently stretched canvas has been used instead. That can lead to cracks and eventual mechanical failure of the paint layer. Egg tempera on wood panel was the favoured combination for easel paintings during the early Renaissance, particularly in Italy.

The finest paintings in egg tempera use only fresh eggs; as eggs age, particularly when they’re not refrigerated, separating the yolk becomes more difficult, and the resulting paint layer doesn’t appear as strong.

Since the nineteenth century, some paint manufacturers such as Sennelier have offered tubed paints with egg as their main binder, but with the addition of some drying oil to form an egg-oil emulsion. These have some of the properties of pure egg tempera, but are more versatile in their handling, and can be used like gouache and even, to a degree, like oil paints. These appear to have been derived from recipes recorded during the Renaissance.

Earliest European examples of egg tempera, such as Margarito d’Arezzo’s The Virgin and Child Enthroned, with Scenes of the Nativity and the Lives of the Saints from the middle of the thirteenth century, often incorporate extensive gilding and today might appear ‘primitive’.

Even the earliest paintings in egg tempera can be remarkably well preserved, such as Duccio’s Healing of the Man born Blind from the early fourteenth century. Although it only forms a thin paint layer, egg yolk is sufficient to preserve high levels of chroma in the pigments.

As the modelling of flesh and clothing became more realistic, egg tempera proved more than sufficient for the task.

One of the finest early works painted entirely in egg tempera is the anonymous Wilton Diptych in London’s National Gallery. Thought to have been made in France at the end of the fourteenth century, its exquisite detail would have been painted in multiple thin layers using fine brushes, much like miniatures painted on vellum.

But it was in Italy that painting in egg tempera reached its apogee, with masters like Masaccio, in his Santa Maria Maggiore Altarpiece from about 1428-29 (above) and Piero della Francesca’s Baptism of Christ (below) of a decade later.

During the fifteenth century, egg tempera was progressively replaced by oils in Italy, as it had been earlier in the Northern Renaissance.

Uccello’s large panel of the Battle of San Romano incorporated some drying oils, including walnut and linseed, although it was still fundamentally painted in egg tempera.

By the end of the fifteenth century, many studios had changed to oils. Among the last large egg tempera paintings are Botticelli’s Primavera (above) and The Birth of Venus (below), from the 1480s. The craft labour involved in producing these large works must have been enormous. Although Primavera was painted on a panel, Venus is on canvas, making it more manageable given its size of nearly 2 x 3 metres (79 x 118 inches).

In the closing years of the fifteenth century, Michelangelo kept to the hallowed tradition of egg tempera on wood in this unfinished painting of the Virgin and Child known now as The Manchester Madonna. This shows how he painstakingly completed each of the figures before moving onto the next, and the characteristic green earth ground.

By this time, the only common use for egg tempera was in the underpainting before applying oils on top. This remains a controversial practice: performed on top of gesso ground it can be successful, but increasingly studios transferred to oils. Egg tempera didn’t completely disappear, though. With so many fine examples of how good its paintings both look and age, there were always some artists who have chosen it over oils.

Some nineteenth century movements that aimed to return to the more wonderful art of the past experimented again with egg tempera. In the late 1870s, John Roddam Spencer Stanhope started to use the medium, and made one of his finest works, Love and the Maiden (1877), using it.

A later exponent who was rigorous in his technique was Adrian Stokes, who used it to great effect in this landscape of Autumn in the Mountains in 1903.

But for my taste, the greatest painter in egg tempera since the Renaissance has to be one of the major artists of the twentieth century: Andrew Wyeth (1917–2009). As his works remain in copyright, I recommend that you browse his official site, where you can see just how effective egg tempera can be in the hands of a great master. It may not be as popular as in the past, but egg tempera still has a great deal to offer.

Earlier in this series, I showed an example of the origin of all modern paintings in the decorated caves of pre-history. As shelters became buildings, our ancestors continued to paint their walls, using a technique now known as secco wall or mural painting, where wet paint is applied to dry stone or plaster.

Secco has been widely used outside Europe, and can still be seen in some very old European wall paintings, such as those in Braunschweig Cathedral, including Christ Pantocrator, thought to date from the early thirteenth century. Long before that was created, though, wall painting advanced to improve adhesion between its paint layer and ground. In secco technique, only thin layers of pigment can be used, resulting in weak colours, little detail, and the need for periodic re-painting as pigment is gradually lost over time.

Artists experimented with different binders and secco techniques. Although dry plaster is more absorbent and a better ground than bare stone, success has been limited, and failure a constant danger. At some time before about 1700 BCE, one of the Mediterranean cultures discovered that it was possible to apply paint onto a layer of wet plaster, and the technique of fresco (strictly, buon fresco) was born.

The Romans loved frescos that made their rooms look as if they were in a spacious outdoors, like this from the House of the Golden Bracelet in Pompeii.

In fresco, the support remains the wall or ceiling of the building, but the ground is absorbent wet plaster applied to that surface. Pigment is diluted in water and applied directly to the ground while the latter is still wet; this allows the paint to be absorbed into the ground, providing good and durable bonding of the pigment. Plaster is made using lime, derived from crushed limestone, and sets by reaction with carbon dioxide in the air to form calcium carbonate (from which both chalk and limestone are composed) and water, which evaporates during drying.

Techniques became even more refined, with the use of additional layers of plaster prepared in specific ways, to which red pigment sinopia might be added, allowing the artist to draw construction and other lines to assist in final painting. Because these frescos are on a grand scale, transferring the design of a painting from final sketch to the wall or ceiling is also a challenge.

The central problem for the painter is that, to be successful, fresco has to be painted onto the plaster when it is still wet. That means only a limited area can be plastered and painted each day, known as giornate (singular giornata), a day’s work. For all but the smallest of ground-level fresco paintings, work has to be undertaken at height, from a scaffold, posing the very real risk that the artist would fall, or the scaffolding fail. Many fresco painters have fallen at work, some suffering serious injuries or death as a result.

Despite all these practical difficulties, some of the most important European works of art are frescos painted during the Renaissance in places of worship with their high walls and ceilings.

Masaccio’s magnificent fresco of The Holy Trinity in the Basilica of Santa Maria Novella in Florence, was painted in 1426-28. At the outset he would have made a preliminary plan including his giornate starting at the top and working downwards. Once ready to start the painting, a team of carpenters will have erected wooden scaffolding to give the artist and his assistants access to the whole of that section of the wall, to the full height of over six metres (21 feet). The first stage would then have been completed by assistants, who laid a rough under-layer of plaster known as the arriccio over the whole wall, and left it to dry for several days. This layer often contains abrasive sand particles to provide a key for the final layer of plaster.

Once that had dried completely, Masaccio and his assistants transferred the drawings onto the surface of the arriccio. This may have been performed by scaling up from the squared drawing and painting with sinopia, or full-size drawings may have been pricked to make holes in the paper and a bag of soot banged against the sheet held against the wall, a technique known as pouncing. Masaccio is known to have used both techniques, and may well have used each in different sections of this work.

On each day of painting, assistants would prepare the colours by mixing pigments in water. The day’s supply of plaster, the intonaco, is then prepared by mixing water with lime. That day’s giornata is covered with a thin layer of intonaco, and about an hour later Masaccio started painting into it. He then had about eight hours before it dried and he could apply no more fresh paint. Like many of the best fresco painters, Masaccio extended his painting time by using paint mixed with milk or casein and a little lime, effectively a lime-based casein medium, which could be laid onto dry intonaco.

The geometric requirements of this painting also merited special measures. When the intonaco was first applied, it was marked to indicate key construction lines, such as those in the barrel-vaulted ceiling, and down the pillars at the side. The remains of these incised lines are still visible when the fresco is viewed in raking light. In this case, there is evidence that Masaccio used lengths of string attached to a nail sunk at the vanishing point of the linear projection, below the base of the cross.

Although we think of frescos as being fixed, this one has now been moved twice within the same church, which hasn’t helped its appearance. During conservation work and movement of Masaccio’s painting in the 1950s, the opportunity was taken to study its construction. Leonetto Tintori drew up a plan of all the identified construction lines and edges of giornate; I have sketched in the latter from a reproduction of a drawing made at that time, which has since been destroyed.

It’s estimated the whole painting would have required some 24 giornate, although because of the long history of damage and attempts at its restoration, that number remains flexible. Assuming that Masaccio painted six days a week, that would have required a minimum of four weeks working for at least ten hours each day. Fresco painting doesn’t permit easy alterations either: if any repainting was required and couldn’t be accomplished using dry technique, that day’s giornata would have to be removed, replaced and repainted.

Giornate can sometimes become obvious over time, as shown in Giotto’s fresco in the Scrovegni Chapel in Padua, Italy.

Perhaps the most famous fresco is Michelangelo’s The Last Judgement (1536-41) in the Sistine Chapel of the Vatican. It covers an area of 13.7 by 12 metres (539 by 472 inches), and took over four years to complete.

In the eighteenth and nineteenth centuries, fresco became relatively neglected.

Some new frescos were commissioned for places of worship and other public buildings, and in the early nineteenth century Johann Friedrich Overbeck painted a series telling the story of Torquato Tasso’s epic Jerusalem Delivered, in the Casa Massimo in Rome. There are similar series showing Dante’s Divine Comedy and other long narratives, which are particularly suited to the medium.

In 1845, the Scottish artist William Dyce was invited to paint frescos for the Royal Family, for which he travelled to Italy to learn technique. On his return in 1847, he painted this curious composition in Queen Victoria and Prince Albert’s new and luxurious holiday palace of Osborne House, at East Cowes, on the Isle of Wight. Neptune Resigning to Britannia the Empire of the Sea (1847) is an impressive fresco, and remains in pristine condition at the top of the main staircase in the house.

Frescos have continued in religious painting, with artists such as Sergei Fyodorov painting them in churches and cathedrals, and for the occasional trompe l’oeil. John Dixon Batten’s The Creation of Pandora was painted anachronistically in egg tempera on a fresco ground by 1913. Batten was one of the late adherents of the Pre-Raphaelite movement; this painting was deemed unfashionable in 1949, and was put into storage and quietly forgotten until its rediscovery in 1990.

New frescos are still painted in some public buildings too. This work by Finnish painter Akseli Gallen-Kallela is one of a series he painted in the National Museum of Finland in Helsinki in 1928, but most other wall paintings of the twentieth century, such as those of John Singer Sargent in public buildings in Boston, have been painted in oils on canvas rather than buon fresco.

Frescos aren’t the only way of making very large and monumental paintings for places like churches, though. The walls of Venetian buildings are particularly unsuitable for secco or fresco, because they remain so damp all year round. Hence the painters of Venice were innovators in constructing very large canvases, and you will find few frescos there as a result.

The humble domestic chicken is probably the most common and widely distributed farm animal. It originated in about 8,000 BCE in south-east Asia and spread its way steadily across every continent except Antarctica. It probably reached Europe before the Roman Empire, and since then has been commonplace. Perhaps because of its small size and frequent presence, it features in relatively few paintings.

The cruel sport of cockfighting accompanied its spread, and is depicted in Jean-Léon Gérôme’s first successful painting in 1846.

This motif had started from a relief showing two adolescent boys facing off against one another. Gérôme felt he needed to improve his figurative painting, and after Delaroche’s advice decided to develop that image by replacing one of the boys with a girl. In both Greek and English (but not French) the word cock is used for both the male genitals and a male chicken, and the youthful Gérôme must have found this combined visual and verbal pun witty and very Neo-Greek.

There’s a curious ambivalence in its reading too: two cocks are fighting in front of the young couple. Is one of the birds owned by the girl, and if so, is it the dark one on the left, which appears to be getting the better of the bird being held by the boy? Either way, it’s a lightly entertaining reflection on courtship and gender roles, and a promising debut. The Cock Fight earned Gérôme a third-class medal, and he sold the painting for a thousand francs. With the benefit of favourable reviews from critics, the following year brought him lucrative commissions, and a growing reputation.

A dead chicken plays a significant role in one of Rembrandt’s most famous group portraits.

His vast group portrait of The Night Watch (1642) is the most famous of all those of militia in the Dutch Republic. It features the commander and seventeen members of his civic guard company in Amsterdam. Captain Frans Banninck Cocq (in black with a red sash), followed by his lieutenant Willem van Ruytenburch (in yellow with a white sash) are leading out this militia company, their colours borne by the ensign Jan Visscher Cornelissen. The small girl to the left of them is carrying a dead chicken, a curious symbol of arquebusiers, the type of weapon several are carrying.

For a young child, cockerels can appear large and threatening, as used by Gaetano Chierici in a delightful visual joke.

His undated painting of A Scary State of Affairs calls on our experience of the behaviour of cockerels and geese. An infant has been left with a bowl on their lap, and their room is invaded first by cockerels, then by those even larger and more aggressive geese. The child’s eyes are wide open, their mouth at full stretch in a scream, their arms raised, and their legs are trying to fend the birds away.

Being among the most humble and everyday domestic species, chickens seldom make the limelight in religious narratives.

Murillo’s Adoration of the Shepherds from about 1650 is an exception featuring unusual additional details including the old woman carrying a basketful of eggs, and chickens in front of the kneeling shepherd.

In most paintings including chickens, though, they are just extras in the farmyard.

Paulus Potter’s Figures with Horses by a Stable (1647) includes finely painted horses, chickens, a dog, and distant cattle, with a magnificent tree in the centre and a sky containing several birds.

In Chickenfeed from 1867, Hans Thoma tackles this genre scene in a traditional and detailed realist style.

Alberto Pasini’s Market Scene from 1884 has an eclectic mixture of produce, ranging from live chickens to pots and the artist’s signature melons.

Évariste Carpentier’s undated Eating in the Farmyard, an example of the rural deprivation which sparked Naturalist art, shows two kids surrounded by animals and birds in this much-used space.

Here, Carpentier’s old woman is busy Feeding the Chickens.

Friedrich Eckenfelder’s Zollernschloss, Balingen from about 1884-5 shows a small yard just below the back of this castellated farm in Germany, with its lively flock of chickens.

Gustav Klimt had probably painted his first small landscapes between 1881-87, and returned to the genre more seriously in about 1896. This work, variously known as After the Rain, Garden with Chickens in St. Agatha, or similar, is thought to have been painted when Klimt stayed in the Goiserer Valley with the Flöge family in the summer of 1898.

Very occasionally, a chicken may come as something of a surprise.

Hieronymus Bosch’s Ship of Fools, a fragment from a larger Wayfarer triptych painted in 1500-10, is actually a small boat, into which six men and two women are packed tight. Its mast is unrealistically high, bears no sail, and has a large branch lashed to the top of it, in which is Bosch’s signature owl. Its occupants are engaged in drinking, eating what appear to be cherries from a small rectangular tabletop, and singing to the accompaniment of a lute being played by one of the women. A man has climbed a tree on the bank to try to cut down the carcass of a chicken from high up the mast.

原文地址：https://www.lxware.cn/archives/halo-meilisearch

Halo 从 2.0 版本开始支持了全文搜索功能，自带的 Lucene 搜索引擎在轻度使用场景下可以满足需求，但在重度依赖搜索功能的场景下，可能在搜索速度和用户体验上存在不足，这时我们会更推荐使用独立的搜索引擎。

本文将介绍如何使用 https://www.meilisearch.com/ 搜索引擎来提升 Halo 网站的搜索体验。

搭建 Meilisearch 服务

部署 Meilisearch 服务通常有两种方式：你可以选择自行在服务器上托管，或者使用 Meilisearch 官方提供的云服务。

云服务

访问 https://www.meilisearch.com/cloud 注册账号，根据引导创建项目。创建完成后，可以在控制台获取实例地址和 Master Key。

需要特别注意 Meilisearch 云服务的计费方式。

自托管

下面介绍两种常见的部署方式：

使用 Docker Compose 独立编排部署

这种方式适合多个项目需要同时使用一个 Meilisearch 服务的场景。 部署完成后，你可以配置域名和反向代理来暴露服务到公网。

services:
  meilisearch:
  image: getmeili/meilisearch:v1.15
  restart: unless-stopped
  ports:
    - "7700:7700"
  environment:
    - MEILI_ENV=production
// [!code highlight]
    - MEILI_MASTER_KEY=<your-super-secret-master-key-here>
  volumes:
    - meilisearch_data:/meili_data

volumes:
  meilisearch_data:
    driver: local

与 Halo 的 Compose 编排一起部署

结合 使用 Docker Compose 部署 Halo 的示例，将 Meilisearch 服务添加到 docker-compose.yml 文件中。

通过这种方式部署之后，插件设置中的 Meilisearch 服务地址 应该是 http://meilisearch:7700（即服务在同一 Compose 网络下可通过服务名访问）

meilisearch:
  image: getmeili/meilisearch:v1.15
  restart: on-failure:3
  networks:
    - halo_network
  volumes:
    - ./meilisearch-data:/meili_data
  environment:
    - MEILI_ENV=production
// [!code highlight]
    - MEILI_MASTER_KEY=<your-super-secret-master-key-here>

version: "3"

services:
  halo:
    image: registry.fit2cloud.com/halo/halo:2.21
    restart: on-failure:3
    depends_on:
    halodb:
      condition: service_healthy
    networks:
    halo_network:
    volumes:
      - ./halo2:/root/.halo2
    ports:
      - "8090:8090"
    healthcheck:
    test:
      ["CMD", "curl", "-f", "http://localhost:8090/actuator/health/readiness"]
    interval: 30s
    timeout: 5s
    retries: 5
    start_period: 30s
    environment:
      - JVM_OPTS=-Xmx256m -Xms256m
    command:
      - --spring.r2dbc.url=r2dbc:pool:postgresql://halodb/halo
      - --spring.r2dbc.username=halo
      - --spring.r2dbc.password=openpostgresql
      - --spring.sql.init.platform=postgresql
      - --halo.external-url=http://localhost:8090/
  halodb:
    image: postgres:15.4
    restart: on-failure:3
    networks:
    halo_network:
    volumes:
      - ./db:/var/lib/postgresql/data
    healthcheck:
    test: ["CMD", "pg_isready"]
    interval: 10s
    timeout: 5s
    retries: 5
    environment:
      - POSTGRES_PASSWORD=openpostgresql
      - POSTGRES_USER=halo
      - POSTGRES_DB=halo
      - PGUSER=halo
// [!code focus:10]
  meilisearch:
    image: getmeili/meilisearch:v1.15
    restart: on-failure:3
    networks:
      - halo_network
    volumes:
      - ./meilisearch-data:/meili_data
    environment:
      - MEILI_ENV=production
      - MEILI_MASTER_KEY=<your-super-secret-master-key-here>

networks:
  halo_network:

详细的部署方式可以参考 Meilisearch 官方文档：https://www.meilisearch.com/docs/learn/self_hosted/install_meilisearch_locally

安装插件

之前 Halo 社区中已经有人开发了 Meilisearch 插件，但已经不再维护，因此这里我们选择使用 Halo 官方提供的插件。

1. 下载插件，目前提供以下两种下载方式：

   • Halo 应用市场：https://www.halo.run/store/apps/app-7mb5szjt

   • GitHub Releases：访问 Releases 下载 Assets 中的 JAR 文件。

2. 安装插件，插件安装和更新方式可参考：https://docs.halo.run/user-guide/plugins

配置插件

1. 进入插件设置，配置 Meilisearch 服务地址 和 Master Key。索引名称 可以选择使用默认的 halo 或者自定义（如果你的 Meilisearch 服务会被多个项目使用，建议自定义索引名称）。

   

2. 进入插件扩展配置，在 扩展点定义 中选择 搜索引擎，然后选择使用 Meilisearch。

   

数据概览

配置完插件后，我们可以进入插件的 数据概览 页面，查看 Meilisearch 的索引数据。

在这个页面中，你还可以重建索引或测试搜索功能。

对比

Lucene（默认搜索引擎）与 Meilisearch 的实际对比：

Meilisearch	Lucene（默认）

通过实际使用可以发现，Meilisearch 的搜索结果更加准确，搜索速度更快，并且支持更灵活的搜索语法，无需用户掌握复杂的搜索表达式即可获得理想的搜索结果。

注意

1. 如果配置完 Meilisearch 插件之后无法搜索，可以尝试重建一次索引。

2. 安装 Meilisearch 插件之后仍然需要https://www.halo.run/store/apps/app-DlacW插件，Meilisearch 插件仅仅是提供服务，不会提供 UI。

原文地址：https://www.lxware.cn/archives/halo-content-tools

在 Halo 社区中，导入 Markdown 和 Word 文档的需求一直很高，但社区一直缺乏完善的解决方案。其主要原因在于 Markdown 和 Word 的文档格式较为复杂，难以完美支持所有格式特性，且图片资源的处理存在技术难点。

现在，社区中已经有了一个插件可以很好地支持导入 Markdown 和 Word 文档，它就是 https://www.halo.run/store/apps/app-SUvBR。该插件不仅支持导入 Markdown 和 Word 文档，还能够智能处理和导入图片资源，为用户提供了完整的文档迁移解决方案。

安装

可以通过以下两种方式安装插件：

1. 访问 https://www.halo.run/store/apps/app-SUvBR 页面直接下载

2. 在 Console 内置的应用市场中搜索 内容助手 进行安装

导入 Markdown 文档

安装并启用插件后，就可以在 Console 侧边菜单的工具中找到 文章导入 的入口。点击进入后，选择 Markdown 导入 选项卡即可开始导入，如下图：

功能详解

1. 选择 Markdown 文件：用于选择单个 Markdown 文档，支持 .md 格式文件。

2. 选择 Markdown 文件夹：用于选择包含 Markdown 文档的文件夹。选择文件夹后，系统会自动扫描其中的所有 Markdown 文档以及图片资源（如有）。

3. 选择图片文件夹：用于选择 Markdown 文档中引用的图片资源。选择文件夹后，系统会自动扫描其中的所有图片资源并在导入时自动关联。

4. 转为富文本格式：默认情况下，导入的 Markdown 文档会保持原有的 Markdown 格式。如果勾选此选项，系统会将文档转换为富文本格式，便于后续使用 Halo 的默认编辑器进行编辑。

使用场景

• 从其他博客平台或写作工具迁移文章内容

• 导入使用本地 Markdown 编辑器创作的文章

• 批量导入历史文档和资料

注意事项

1. 导入 Markdown 文档后，如果需要在 Console 中编辑文章，请确保已经安装了任意一个 Markdown 编辑器插件，否则无法正常打开编辑页面。

2. 如果 Markdown 文档中引用了本地图片资源，请在导入前选择存放图片的文件夹，否则图片将无法正确上传和关联。

3. 系统支持自动解析 Front Matter（文档头部的元数据），包括标题、别名（slug）、描述、摘要、分类、标签等信息。

操作示例

选择 Markdown 文件：

选择图片文件夹（如果文档包含本地图片）：

点击导入，等待导入完成：

检查文章与图片资源是否导入成功：

导入 Word 文档

进入 文章导入 页面后，选择 Word（.docx）导入 选项卡，如下图：

功能详解

1. 选择 Word 文档：用于选择单个 Word 文档，支持 .doc 和 .docx 格式。

2. 选择 Word 文档文件夹：用于批量选择包含 Word 文档的文件夹。

3. 转为 Markdown 格式：默认情况下，导入的 Word 文档会转换为富文本格式。如果希望后续使用 Markdown 编辑器编辑文章，请勾选此选项将内容转换为 Markdown 格式。

使用场景

• 将公司内部的 Word 文档转换为博客文章

• 配合 https://maxkb.cn/ 智能知识库，建立企业知识管理体系

• 从传统文档工具迁移内容到现代化的管理平台

注意事项

1. 由于 Word 文档格式的复杂性，系统可能无法完美解析所有内容格式，建议导入后进行适当调整。

2. 系统支持自动导入 Word 文档中的图片资源，但其他类型的嵌入对象暂不支持。

3. 图片会上传到与个人中心关联的存储策略，请提前在用户设置中配置相关参数。

操作示例

选择 Word 文档：

点击导入，等待导入完成：

检查文章是否导入成功：

丰富的内容管理功能

除了核心的导入功能，内容助手还提供了丰富的内容管理功能：

格式转换

支持 Markdown 与富文本格式的双向转换，让用户可以根据编辑需求灵活切换文档格式。你可以在文章管理页面点击文章的 ··· 按钮，在转换菜单中选择相应的格式转换选项，也可以在文章编辑页面顶部的编辑器选择框中选择 内容格式转换器 进行转换。

文章导出

支持将文章导出为多种格式，方便内容备份和分享：

• 以原格式导出：保持文章的原始格式进行导出

• 转换为 Markdown 并导出：将文章转换为 Markdown 格式后导出

• 转换为 PDF 并导出：将文章转换为 PDF 格式进行导出

文章克隆

提供文章克隆功能，便于基于现有文章创建相似内容。克隆后的文章会自动在标题后添加"（副本）"标识，并生成新的别名以避免冲突。

以上功能都可以在文章管理页面点击文章的 ··· 按钮找到相应选项。

总结

内容助手插件为 Halo 用户提供了完整的文档导入和内容管理解决方案，有效解决了 Markdown 和 Word 文档的导入难题。插件不仅支持智能处理图片资源，还提供了格式转换、文章导出、文章克隆、内容复制等丰富功能，能够满足大部分用户的内容管理需求。

无论你是从其他平台迁移内容，还是需要批量导入历史文档，内容助手都能为你提供便捷、高效的解决方案。如果你有文档导入或内容格式转换的需求，欢迎尝试使用内容助手插件。

更新（25-06-19）

现在已经为插件的 UI 部分提供了新的配置方式，https://www.npmjs.com/package/@halo-dev/ui-plugin-bundler-kit 包提供了 rsbuildConfig 方法，可以更加方便的使用 https://rsbuild.dev/ 来构建 UI 部分。

Rsbuild 基于 Rspack 构建，提供了更完善的 loader 配置，所以在封装的时候就直接选择了 Rsbuild。

安装依赖：

pnpm install @halo-dev/ui-plugin-bundler-kit@2.21.1 @rsbuild/core -D

rsbuild.config.mjs:

import { rsbuildConfig } from "@halo-dev/ui-plugin-bundler-kit";

export default rsbuildConfig()

package.json 添加 scripts:

{
  "type": "module",
  "scripts": {
    "dev": "rsbuild build --env-mode development --watch",
    "build": "rsbuild build"
  }
}

需要注意的是，为了适应新版的 https://github.com/halo-dev/plugin-starter，默认生产构建输出目录改为了 ui/build/dist ，如果你要从已有的插件项目迁移到 Rsbuild，建议参考 https://github.com/halo-dev/plugin-starter/pull/52 对 Gradle 脚本进行改动，或者自定义 Rsbuild 的配置以保持原有的输出目录配置：

import { rsbuildConfig } from "@halo-dev/ui-plugin-bundler-kit";

const OUT_DIR_PROD = "../src/main/resources/console";
const OUT_DIR_DEV = "../build/resources/main/console";

export default rsbuildConfig({
  rsbuild: ({ envMode }) => {
    const isProduction = envMode === "production";
    const outDir = isProduction ? OUT_DIR_PROD : OUT_DIR_DEV;

    return {
      resolve: {
        alias: {
          "@": "./src",
        },
      },
      output: {
        distPath: {
          root: outDir,
        },
      },
    };
  },
});

示例：https://github.com/halo-sigs/plugin-migrate

了解更多：https://docs.halo.run/developer-guide/plugin/basics/ui/build

前情提要

Halo 插件的 UI 部分（Console / UC）的实现方式其实很简单，本质上就是构建一个结构固定的大对象，交给 Halo 去解析，其中包括全局注册的组件、路由定义、扩展点等。 基于这个前提，在实现插件机制时，主要面临的问题就是如何将这个大对象传递给 Halo。当初做了非常多的尝试，最终选择构建为 IIFE（Immediately Invoked Function Expression，立即执行函数），然后 Halo 通过读取 window[PLUGIN_NAME]（PLUGIN_NAME 即插件名）来获取这个对象。 构建方案采用 Vite，并提供了统一的构建配置。回过头来看，这个方案存在不少问题：

1. 会污染 window 对象，虽然目前并没有出现因为这个导致的问题，但是从长远来看，这个方案并不是最优的。（当然，使用 Rspack 来构建并不是为了解决这个问题）

2. Vite 不支持 IIFE / UMD 格式的代码分割（主要是 Rollup 还不支持），无法像 ESM（ECMAScript Module）那样实现异步加载模块的机制。

3. 基于第 2 点，如果插件中实现了较多的功能，可能会导致最终产物体积巨大，尤其是当用户安装了过多的插件时，会导致页面加载缓慢。

   1. 以 http://www.halo.run/ 为例，gzip 之前接近 10M 的 bundle.js，gzip 之后也有 2M - 3M。

   2. 以此博客为例，gzip 之后也有 1.8M 的 bundle.js。

4. 基于第 2 点，如果不支持代码分块（Chunk），也无法充分利用资源缓存，访问页面时，也会一次性加载所有插件的代码（即便当前页面不需要）。

基于以上问题，我开始寻找其他替代方案，最终通过翻阅 Rspack（Webpack 的 Rust 实现）的文档发现，Webpack 能够通过配置实现 IIFE 格式的代码分割，最终选择 Rspack 作为尝试。

基本的 Rspack 配置

安装依赖：

pnpm install @rspack/cli @rspack/core vue-loader -D

package.json 添加 scripts:

{
  "type": "module",
  "scripts": {
    "dev": "NODE_ENV=development rspack build --watch",
    "build": "NODE_ENV=production rspack build"
  }
}

rspack.config.mjs:

import { defineConfig } from '@rspack/cli';
import path from 'path';
import process from 'process';
import { VueLoaderPlugin } from 'vue-loader';
import { fileURLToPath } from 'url';

// plugin.yaml 中的 metadata.name
const PLUGIN_NAME = '<YOUR_PLUGIN_NAME>';

const isProduction = process.env.NODE_ENV === 'production';
const dirname = path.dirname(fileURLToPath(import.meta.url));

// 开发环境启动直接输出到插件项目的 build 目录，无需重启整个插件
// 生产环境输出到插件项目的 src/main/resources/console 目录下
const outDir = isProduction ? '../src/main/resources/console' : '../build/resources/main/console';

export default defineConfig({
  mode: process.env.NODE_ENV,
  entry: {
    // 入口文件，可以参考：https://docs.halo.run/developer-guide/plugin/basics/ui/entry
    main: './src/index.ts',
  },
  plugins: [new VueLoaderPlugin()],
  resolve: {
    alias: {
      '@': path.resolve(dirname, 'src'),
    },
    extensions: ['.ts', '.js'],
  },
  output: {
    // 资源根路径，加载代码分块（Chunk）的时候，会根据这个路径去加载资源
    publicPath: `/plugins/${PLUGIN_NAME}/assets/console/`,
    chunkFilename: '[id]-[hash:8].js',
    cssFilename: 'style.css',
    path: path.resolve(outDir),
    library: {
      // 将对象挂载到 window 上
      type: 'window',
      export: 'default',
      name: PLUGIN_NAME,
    },
    clean: true,
    iife: true,
  },
  optimization: {
    providedExports: false,
    realContentHash: true,
  },
  experiments: {
    css: true,
  },
  devtool: false,
  module: {
    rules: [
      {
        test: /\.ts$/,
        exclude: [/node_modules/],
        loader: 'builtin:swc-loader',
        options: {
          jsc: {
            parser: {
              syntax: 'typescript',
            },
          },
        },
        type: 'javascript/auto',
      },
      {
        test: /\.vue$/,
        loader: 'vue-loader',
        options: {
          experimentalInlineMatchResource: true,
        },
      },
    ],
  },
  // 这部分依赖已经由 Halo 提供，所以需要标记为外部依赖
  externals: {
    vue: 'Vue',
    'vue-router': 'VueRouter',
    '@vueuse/core': 'VueUse',
    '@vueuse/components': 'VueUse',
    '@vueuse/router': 'VueUse',
    '@halo-dev/console-shared': 'HaloConsoleShared',
    '@halo-dev/components': 'HaloComponents',
    '@halo-dev/api-client': 'HaloApiClient',
    '@halo-dev/richtext-editor': 'RichTextEditor',
    axios: 'axios',
  },
});

配置需要懒加载的路由或者组件：

在 index.ts 中配置路由：

import { definePlugin } from '@halo-dev/console-shared';
import { defineAsyncComponent } from 'vue';
import { VLoading } from '@halo-dev/components';
import 'uno.css';
// [!code --]
import DemoPage from './views/DemoPage.vue';

export default definePlugin({
  routes: [
    {
      parentName: 'Root',
      route: {
        path: 'demo',
        name: 'DemoPage',
// [!code --]
        component: DemoPage,
// [!code ++:4]
        component: defineAsyncComponent({
          loader: () => import('./views/DemoPage.vue'),
          loadingComponent: VLoading,
        }),
      ...
      },
    },
  ],
  extensionPoints: {},
});

注：推荐使用 defineAsyncComponent 包裹，而不是直接使用 () => import() 的方式，后者会在进入路由之前就开始加载页面的代码分块（Chunk），导致页面在加载期间没有任何响应。

构建产物示例：

❯ ll src/main/resources/console
.rw-r--r-- 191k ryanwang staff 16 Jun 10:47  359-3bebb968.js
.rw-r--r--  83k ryanwang staff 16 Jun 10:47  962-3bebb968.js
.rw-r--r-- 4.1k ryanwang staff 16 Jun 10:47  main.js

其他配置

集成 Scss / Sass

安装依赖：

pnpm install sass-embedded sass-loader -D

rspack.config.mjs 添加配置：

import { defineConfig } from '@rspack/cli';
import path from 'path';
import process from 'process';
import { VueLoaderPlugin } from 'vue-loader';
import { fileURLToPath } from 'url';
// [!code ++]
import * as sassEmbedded from "sass-embedded";

...

export default defineConfig({
  ...
  module: {
    rules: [
      ...
// [!code ++:13]
      {
        test: /\.(sass|scss)$/,
        use: [
          {
            loader: "sass-loader",
            options: {
              api: "modern-compiler",
              implementation: sassEmbedded,
            },
         },
        ],
        type: "css/auto",
      },
    ],
  },
...
});

集成 UnoCSS

如果你习惯使用 TailwindCSS 或者 UnoCSS 来编写样式，可以参考以下配置：

本文推荐使用 https://unocss.dev/，因为可以利用 UnoCSS 的 https://unocss.dev/transformers/compile-class 来编译样式，预防与 Halo 或者其他插件产生样式冲突。

安装依赖：

pnpm install unocss @unocss/webpack @unocss/eslint-config style-loader css-loader -D

入口文件（src/index.ts）添加导入：

import 'uno.css';

rspack.config.mjs 添加配置：

import { defineConfig } from '@rspack/cli';
import path from 'path';
import process from 'process';
import { VueLoaderPlugin } from 'vue-loader';
import { fileURLToPath } from 'url';
// [!code ++]
import { UnoCSSRspackPlugin } from '@unocss/webpack/rspack';

...

export default defineConfig({
  ...
  plugins: [
    new VueLoaderPlugin(),
// [!code ++]
    UnoCSSRspackPlugin()
  ],
  ...
  module: {
    rules: [
      ...
// [!code ++:5]
      {
        test: /\.css$/i,
        use: ['style-loader', 'css-loader'],
        type: 'javascript/auto',
      },
    ],
  },
...
});

uno.config.ts:

import { defineConfig, presetWind3, transformerCompileClass } from 'unocss';

export default defineConfig({
  presets: [presetWind3()],
  transformers: [transformerCompileClass()],
});

.eslintrc.cjs:

/* eslint-env node */
require('@rushstack/eslint-patch/modern-module-resolution');

module.exports = {
  root: true,
  extends: [
    'plugin:vue/vue3-recommended',
    'eslint:recommended',
    '@vue/eslint-config-typescript/recommended',
    '@vue/eslint-config-prettier',
// [!code ++]
    '@unocss',
  ],
  env: {
    'vue/setup-compiler-macros': true,
  },
// [!code ++:3]
  rules: {
    "@unocss/enforce-class-compile": 1,
  },
};

总结

以上就是针对 Halo 插件前端部分的 Rspack 配置。我已经对 Halo 官方维护的部分插件进行了迁移，几乎没有遇到什么问题，并且带来的收益非常明显：www.halo.run 和本博客的 bundle.js 在 gzip 之后仅有不到 200k，各个页面也只会在访问时加载所需的资源。

需要注意的是，我对这些构建工具并不算非常熟悉，所以配置仍然有优化空间。我们会持续优化，后续也会考虑提供一个通用的 CLI 或 Rspack 配置，期望实现如下效果：

rspack.config.mjs:

import { rspackConfig } from '@halo-dev/ui-bundler-kit';

export default rspackConfig({
  ...
});

或者基于 Rspack 包装一个 CLI：

plugin.config.mjs:

import { defineConfig } from '@halo-dev/ui-bundler-kit';

export default defineConfig({
  ...
});

package.json:

{
  "scripts": {
    "dev": "halo-ui dev",
    "build": "halo-ui build"
  }
}

参考文档

• https://rsbuild.dev/

• https://rspack.rs/

• https://webpack.js.org/concepts/

感谢阅读，欢迎交流与指正！