
Ivy – A static website generator built in Python - dm40597
http://mulholland.xyz/docs/ivy/
======
bgrohman
It looks nice, but I guess I still[1] don’t understand the proliferation of
simple static site generators. It’s pretty easy (and fun!) to build your own
that works exactly as you want it to. And I don’t think a static site
generator is suitable for non-technical users. Is there an in-between type of
user technical enough to use a static site generator but not able to write
their own? Or maybe the proliferation is only because they are both easy and
fun to create?

[1][https://news.ycombinator.com/item?id=14877298](https://news.ycombinator.com/item?id=14877298)

Edit: I didn’t intend for this to sound negative for the creator. Even if it’s
just for fun and the chance someone else might find it useful, that’s enough
of a reason to build it for me.

~~~
bane
Learning how to program, especially when one doesn't come about it through
self-selected autodidactism, can often seem to be an insurmountable challenge
to people who don't know how.

This applies to even extremely technical, highly intelligent people. Often
they recognize that there's an extraordinary time component to learning, and
they optimize around that in other ways.

Learning to program is a weird thing because once you learn the mental
processes of how to do it, it comes fairly easily. But the idea of "I'd like a
tool that makes websites for me" and then knowing how to divide that problem
down to the right mental abstraction model that perfectly (or near perfectly
fits) some programming language and technical environment is a very difficult
learning curve.

It's much simpler then to present small technical pieces that are well
constrained in scope and definition and have tooling somebody else built do
all the rest of the heavy lifting.

Static site generators are one of those things that are relatively easy, even
for newish programmers, to build, but exist right on the other side of that
learning curve for non-programmers.

~~~
stult
Also, as a non-front end developer, I don't have HTML fresh in my mind and
don't care to. Sometimes you just want to do something quick and not have to
worry about it.

------
jaredandrews
Not sure if OP is the developer behind this but...

As a happy user of Pelican[0], a different Python based static site generator.
Why would I want to switch over to Ivy?

[0] [https://blog.getpelican.com/](https://blog.getpelican.com/)

~~~
nicolaslem
Pelican is great, I find it very flexible thanks to its many plugins. I wished
it was maintained a bit more though, there are a lot of PRs waiting for
reviews[0].

[0] [https://github.com/getpelican/pelican-
plugins](https://github.com/getpelican/pelican-plugins)

~~~
hdra
That is just the plugins repository. I think a wiki model would work better
for that kind of listing.

------
manigandham
Lots of static site generators now - this is useful to check:
[https://www.staticgen.com/](https://www.staticgen.com/)

------
fiatjaf
It's odd that this has gotten so many upvotes while there are thousands of
other static site generators[1] and this one doesn't even provide a single
explanation as to why it is different or why would someone prefer this over
one of the most famous ones.

[1]: [https://www.staticgen.com/](https://www.staticgen.com/)

------
viperscape
No purchase necessary! The title and the slogan on the site seem to infer
something else. It's public domain source, it says at the bottom of the page.
Glad to see more static generators, not sure how this is better or different
than the other many

~~~
ezekg
Thanks for the clarification. I was looking everywhere for a price tag but
couldn’t find it. Was excited to see another dev charge for their work! Maybe
the title of this post should be changed so it’s less confusing?

------
dod9er
Sorry for offtopic, but I´ve seen many nice-looking website generators here,
but being a backend-guy I struggle more with the frontend, getting a nice
layout/theme/font without deepdiving into css/js/html. Any suggestions here ?
Any Wysiwyg-Editor which generates a reasonable output ?

~~~
TheAceOfHearts
* Avoid custom fonts. You probably don't need a custom font. Just use system fonts. Using built-in fonts will allow your site to load faster.

* Getting a "nice layout/theme" is a design problem. I'd suggest following someone's style guide. I'm fond of the U.S. Web Design System [0] since it's lightweight and accessible. Disagree with their suggestion to use a custom font.

* Keep the layout as simple as possible, with a focus on content. You can go incredibly far with semantic HTML and a smattering of CSS. I don't think it requires a deep-dive.

[0] [https://designsystem.digital.gov/](https://designsystem.digital.gov/)

------
luckydude
I love this sort of static generator for a non-obvious (perhaps) reason: you
can version control the source. I find that hugely useful when maintaining a
complex site.

I wrote a similar tool, years and years ago, that took what looked like "troff
-ms" input and spit out the whole website, complete with a site map. Here's an
example

[http://www.mcvoy.com/lm/bkdocs/UG/tmp/Introduction.html](http://www.mcvoy.com/lm/bkdocs/UG/tmp/Introduction.html)

if you go up a directory level and poke around, that's the source to website
and webroff is the script that produced that website.

~~~
frozenport
Site was done in php with peak user load being around 200 simultaneously
users. I had git on the webroot and a chron job that dumped the sql, and
pushed the whole thing every night.

------
mkesper
Please, everyone, don't use the "unlicense" for software. It makes it
impossible to use / contribute globally. See e.g. here:
[https://softwareengineering.stackexchange.com/questions/1471...](https://softwareengineering.stackexchange.com/questions/147111/what-
is-wrong-with-the-unlicense)

~~~
gw
The fear-mongering about public domain seems to drift further and further from
reality. Is SQLite "impossible" to use globally? Its public domain dedication
is even more terse than the unlicense. If it really does become a practical
issue for Germans, maybe the real problem is the German legal system.

~~~
tscs37
It's unlikely to become a practical issue IMO (not a lawyer) but the German
legal system has simply no notion of dedicating something to public domain
like in the US. From what I've heard in my computer law course in university,
you can safely assume that the authors/copyright holders of software like
SQLite3 will not pursue their rights and use the software. If they decide to
go after you legally, then you have to comply.

So the "unlicense" or "public domain" license is basically not more than a
weak promise that the author won't sue you over any usage which they can break
at any moment. On a proper license, you'd be safe if you comply with the
license.

~~~
terminalcommand
I don't know much about copyright law, but basically if you state the clauses
in the unlicensed license and create the impression that you waive your rights
to the software, you shouldn't be allowed to sue without real cause. That is
to protect the software owner against ill-willed third parties. For example,
if someone has made very minor changes to your software and distributes it
commercially. You could sue that person, if you wanted, granted that you live
in a law system where the copyright laws don't permit the usage of an
unlicensed clause.

Waiving all your present and future claims on a software without any
compensation beforehand could very well not be permitted in many legal
systems. Law systems such as Germany and many other countries do not recognize
software as an intellectual property. Software is recognized as a right which
has personal and economic prospects. It is asserted that you can make legal
acts on the economic prospects, but your ability to make legal acts for the
personal part of your right on the software you've written can be limited.
Because it is believed that there are some rights you have, that you cannot
freely dispose of. For example you cannot make a legal act to become the slave
of someone else, or you cannot trade your life for money. Because of the same
reasons you cannot trade all rights for something you've created (~your
software).

On the other hand, as tscs37 has stated, the unlicensed "license" statement
means that you promise to not pursue your legal rights against anyone who uses
your software. But as there are no parties, no signatures, no compensation,
this is not a license agreement. This could only be regarded as a promise. You
could break it at any moment, change your idea etc. But if you do that without
any cause, you could get sued for damages, because of the trust you've implied
to the other party.

Again, I don't know much about copyright law. I'm just a law student. But
IMHO, you can safely rely on using software that promises to guarantee the
unlicensed clause. If the author of the software changes their minds, you
might have to switch to using a different software but you can in principle
get compensation for all provable costs that this change has caused you or may
cause you in the future.

------
wildermuthn
Looks nice.

If we're going to compile our FE code (sometimes once with production
babel/webpack builds, sometimes more often with every server-side rendered
cache miss), then we might as well go all in with static-site generators. The
epitome of this trend is
[https://www.gatsbyjs.org/](https://www.gatsbyjs.org/), a framework designed
around GraphQL and React.

~~~
fiatjaf
In more-or-less the same niche as Gatsby there is my Sitio[1], which also uses
React (so kinda isomorphic pages), main differences being:

\- No GraphQL stuff, but instead you'll use imperative JS code to tell the
library which pages you want to build, with data from anywhere (files, CMSs,
hosted contents elsewhere etc.) you can fetch using the same JS code,
transform with any library etc.

\- No Webpack, no Webpack transforms. I suffered when I tried to use Gatsby
because of the gigantic dependencies on Webpack. I guess it's changed
nowadays, but still I'm hurt and won't go back there. Here we're proud to use
Browserify and go with more modular architecture.

[1]: [https://github.com/fiatjaf/sitio](https://github.com/fiatjaf/sitio)

------
wiradikusuma
Just FYI, "Ivy" is also the name of a very popular dependency management tool
in Java, maybe like pip in Python.

~~~
d0mine
For me, Ivy is a Emacs package (interactive list narrowing/selection).
[https://youtu.be/VvnJQpTFVDc](https://youtu.be/VvnJQpTFVDc)

------
peller
Looks pretty nice for simple static sites. However on the homepage it says

> You can build any kind of website using Ivy but it's particularly suited to
> building project documentation

But unfortunately I'm not seeing anything about generating source code
documentation from docstrings (like Sphinx). For me, that would make it much
more useful.

------
zmmmmm
General question - I don't understand why so many static site generates,
github, many others, all use templates that won't fill the width of the page.
Is using the full width of the page particularly difficult to design for? Or
is it an aesthetic decision that template authors feel like having a 20 inch
wide monitor with 8 inches of text in the middle flanked by 12 inches of white
space is a nice layout? Particularly for code examples it's very frustrating
seeing lines wrapped around unnecessarily on a large, wide monitor.

(sorry if this sounds like a rant, actually just genuinely curious).

~~~
pleasecalllater
The best length for fast reading is not more than 60-70 characters per line.
That's why you have columns in newspapers. I have a 4k 26 inch monitor. Full
width texts are harder to read, I have to shrink my browser to make the text
not so wide.

------
alant
I tried Jekyll with github and it's awesome (until I can't fix certain
details). If Ivy can integrate with with github that'd be awesome!

------
mikeymop
Nice! I'll have to play with it. It's going to take a lot of uplift me from
Hugo with it's single binary.

------
amelius
> Ivy is a static website generator. It transforms a directory of text files
> into a self-contained website.

Perhaps a stupid question but isn't that what HTML was designed for? It
doesn't even require a generator.

~~~
mixedmath
Suppose for instance you wanted a static blog. Blog engines like wordpress (or
django or flask for python setups) generate parts of the site on the fly as
users visit. For instance, you might generate the most recent 10 posts in some
list somewhere. This requires some (often not much, but some) additional time
from the server as these are generated on the fly.

A static website generator like this allows you to make a blog (for example)
and update content like most-recent-10-post lists (also for example) only when
you actually add a new post. Thus no additional time is required on the fly.

I might add that there is an extension for flask (which I normally think of as
dynamic) called Frozen-Flask which also allows a flask-built site to become a
static site. This probably exists for django as well, but I'm less familiar
with django than flask.

~~~
biscotti
One django app that provides this is django-bakery, you could run the local
server to add or edit content using django-cms or mezzanine then use bakery to
generate a static site to host.

[https://github.com/datadesk/django-
bakery](https://github.com/datadesk/django-bakery)

------
leblancfg
Is there a list of available extensions somewhere?

~~~
jonathonf
[http://mulholland.xyz/docs/ivy/extensions.html](http://mulholland.xyz/docs/ivy/extensions.html)

------
brndnmtthws
How does this compare to something like Jekyll? Is the only difference that
this is written in Python and Jekyll is Ruby?

