@EmilioPisanty There could be two reasons for this. One is that this font actually has different glyph shapes for different font sizes. At small sizes it is thicker and wider, at large sizes it is thinner, more elegant and more detailed. This feature is not well supported unless the font is directly used in LaTeX.

@EmilioPisanty On a Mac in Pages I can actually choose the size style I want, in addition to choosing what size to scale the glyphs to:

But within Mathematica (and in many other programs too) this choice is not available.

In MaTeX you have two different options to control sizing: the FontSize option triggers this choice and the Magnification option simply scales.

It looks like the default style that is chosen (and cannot be changes) within Mathematica is the 10pt one (regardless of FontSize)

In MaTeX the default FontSize is 12. This makes the MaTeX default thinner than when using Latin Modern Roman directly.

This should give identical shapes:

Magnify[Graphics[
  {
   Text[MaTeX["\\text{foobar}", FontSize -> 10], {0, 0}],
   Text[Style["foobar", FontFamily -> "Latin Modern Roman",
     FontSize -> 10], {0, 1}]
   }, ImageSize -> 30
  ], 5]

The other reason for the difference is that MaTeX returns Graphics with filled curves inside. This is rendered differently than fonts. It'll also be different across operating systems, as each render fonts differently ...

Some OS even have an option about how thick to render fonts

This difference should go away if rendering at a high enough resolution or printing on a laser printer

have to go now, sorry @EmilioPisanty

@Szabolcs no I hadn't. thanks. I think that now that FRED data can be accessed built in then there is no need for that package. ...although I have not tested its usage and do not have time currently to do so.

What is a reasonable core subset of Mathematica? Something that is practical and sufficient to program anything. E.g., in C you can learn roughly assignment, if, for, while, break, pointers, structs, malloc/free, and you can do pretty much anything reasonably.

Ah. Damn. I was so happy with a little CDF I made that used Interpreters on an input field. The person I sent it to loved it. Then we sent it to someone who doesn't have Mathematica, and it doesn't work for them because only numeric input fields work with the free CDF plugin.

Mathematica needs a much larger subset to be able to do basic stuff with reasonable efficiency. What would be this subset?

Something that a beginner can be confident with that they can do most anything ... maybe not the best way, but at least in a reasonable way.

They said they will just buy a license though so it will work, so I guess WR would be happy with that response.

@Szabolcs Isn't it paradigm dependent? If you learn lists, Part, If, While, For, Break, and maybe something else you can do the things you can do in your subset of C, right? If you learn patterns you can do rule based programming, if you learn the functional operators, lists, and pattern matching as is needed for function definitions, then you can do functional programming. I like the question though.

@ManuelOdendahl the wolfram cloud does away with the CDFPlayer as the browsers have killed it anyway (PCWorld come up surprisingly high in my google searches, pcworld.com/article/2990991/browsers/…). The support for 3D graphics in the cloud is fairly good. You're US based so I can't help, I'm a Europhile and European - until Article 50 is invoked, anyhow. Technical sales should help you :)

@C.E. But is pure procedural programming relying on these reasonable in Mathematica? I don't think so. It's not just about being Turing complete. I do think that If, Do, While, Break, Part should be included in that subset, but they are not sufficient. I would banish For from the language forever if I could ...

@Szabolcs Your question is timely. I'm no longer merely playing with Mathematica as I did before, yet trying to actually accomplish a moderately complex goal now. The "Intro for Programmers" is a good start, yet its got huge gaps and, honestly, doesn't appear to be written with an actual programmer in mind.

Simple idioms are not present and someone coming from a largely imperative background is quickly lost. On the email importer, I had a short program of about 30 lines that worked. Then, once some realizations set in, I got the basic thing down to 2 lines. And felt like an idiot that i didn't start out that way. AND, there are still issues with the code that i wrote.

While I don't have an answer for you on the 'reasonable' subset, I think its very worth opening a discussion.

SortBy[DeleteMissing@
   WolframLanguageData[All, "Ranks", "EntityAssociation"],
  Total[{"StackExchange", "TypicalProductionCode"} /. #] &][[;; 10]]