I've just published on GitHub a wrapper for TI-SmartView's js emulators, which makes the emu much more usable for screen-recording purposes
Indeed, when you run the emulator inside a recent browser, it's running much, much faster than from within SmartView (because Java's Webview yield poor JS performance, apparently...)

Screenshot:


The files/source + readmes on how to set it up are there (there is a bit of setup since you'll need to provide TI's files like the emu(s) core etc.).

What's in it right now:

• Support of the TI-82A/83+/84+, 84+CSE, 84+CE/83PCE JavaScript emulators
  
• Key history
  
• Big hand pointer ("handy" for presentation purposes)
  
• Screen zooming
  
• Screenshot (.png export, auto-download)
  
• Video capture (webm creation, thanks to WebRTC, currently only working on Chrome)

What's not in it right now:

• File transfers
  
• Debugging support (I have ideas on how to do that, but it's not very practical, and would work on specific versions only, so that's not very good)
  
• Skin switching

So, while we wait for an actual community-made emulator that natively provides all kind of nice user+developer-oriented features, this is the next best thing, I guess

Feel free to report feedback, or even make pull requests


Credits:
- critor, for the hand pointer and key history ideas and initial implementations
- me, for the rest
- TI of course, for the emulators we build things around


(Also posted on TI-Planet and CodeWalrus)

From a technical perspective, this is of course cool work, and shows a good grasp of Javascript reverse-engineering techniques and Javascript coding/API usage in general. From a legal perspective, though, I have some serious qualms about this. Most importantly, it seems you have essentially created a crack for TI-SmartView: if you download TI's trial of TI-SmartView and combine it with this, you get a free SmartView for life without buying anything, and since SmartView includes the ROM, you also get a free emulator without even owning the calculator in question. Were you not concerned about this when you made this tool? Although you are of course correct that you're not expressly publishing TI's code yourself, you are encouraging people to extract a copyrighted/licensed part of TI's tool and insert it into your own tool, which I feel is pretty shady, legally-speaking.

Since this feels like a jab at jsTIfied, I feel like there should be some clarity on this. What features do you mean? What constitutes a community-made emulator? There are plenty of features in jsTIfied that help developers under the CPU tab and it is an emulator available to the community.

I believe he was talking about a community made emulator for the CE

Given the range of what's supported I don't think so:

This actually required no reverse-engineering... except if you call extracting a zip (jar) + looking at html reverse-engineering
R-E however would be needed for implementing file transfers, for example. And that is clearly something I don't have the time for.


This code does not implement many things that makes SmartView what it is: View3 support, file transfers, emulator switching, etc.
And that's kind of normal for a code that's around 200 lines long total (+ around 100 of CSS).
My thing is absolutely no threat to TI's sales, as far as I can see


That is something everyone could have done, I certainly didn't need to be there for people to extract a zip file and launch a .js, especially for the target audience: mainly developers
Moreover, it's actually so obvious that I guess it's better that I did it using caution (not publishing TI's files) that somebody else actually releasing everything publicly.
But I guess your reasoning could also be applied to jsTIfied: you encourage people to dump their rom (because, like here, you don't want to upload TI's files), while TI kinds of locks down (at least, they don't open it very much) native programming on recent devices, since they haven't provided SDKs for years nor RSA keys to make third-party apps development official. And I'm pretty sure TI doesn't like exploits to force native programming onto the platforms they lock down, as much as any other project of the sort, like this one.
Also, let me now quote some interesting paragraph from the OS's license (and probably other TI files too) :

When you apply that down to the letter, jsTIfied would be illegal since it is not an emulator TI made, and my thing would not be at all (I didn't have to reverse-compile/assemble anything ; their emulator is made, well, by TI ; JavaScript files are not object files)


I meant, the CE-compatible version of jsTIfied that KermM talked about here, not necessarily a whole new one (although a CE-compatible WabbitEmu etc. would be nice as well )

The specific issue here is secondary liability for infringement. Copying portions of smartview for use in another tool is pretty clearly infringement to my view (there is no copying exemption for personal use), but uses like that are generally ignored since it's infeasible to enforce. The relevant test for most secondary liability, however, is "substantial noninfringing use" which I believe this tool fails spectacularly because it's completely useless without making copies.

An argument could probably also be made against this as a circumvention tool (permitting unlicensed use of substantial portions of the smartview software), but I find that argument to be somewhat weaker.

All this made me look more at the license within SmartView CE. The relevant (I think) part would be :

I think this brings good news for my project:

• I don't "duplicate any related software documentation"
  
• "At the end of the trial period you agree to cease use of the Program, unless you have purchased a license to use the Program" makes the potential "cracking" issue seen by KermM moot, at least as far as I understand it: "Program" is defined as "The software program(s) in this installation and any related documentation", which includes anything from within the SmartView folder, basically, so the JavaScript emu core as well. Thus, it would be the user's fault to use an expired SmartView file with the wrapper, certainly not the fault of the wrapper (nor its creators)
  
• I haven't "reverse-assemble[d] or reverse-compile[d]" anything, and it's quite obvious: JavaScript isn't assembled nor compiled, for that matter.
  
• Nor do I "sell, rent, lease" etc. the Program.

But anyway, if TI suddenly wants to annoy me to the point of legally asking to erase the GitHub repo, I'd be quite surprised, since they haven't done anything of the sort for community emulators like jsTIfied, WabbitEmu, nspire_emu, etc. which apparently clearly violate the OSes licenses (which I find absurd in that regard).

The copyright holder has many rights that need not be stated. My argument says nothing about their EULA because it does not rely on any kind of contract, so trying to hide behind the smartview EULA is disingenuous.

I'm just saying I'm not violating any of the things that are specifically listed there, as far as I can honestly see.

Technically, literally everything done such as documentation of the OS and creation of any type of emulator outside of TI is a breach of contract. However, the only problem I see with this is the fact that it is actually TI's software, and thus could be a problem for end users since it is unsuported. Honestly, I doubt anyone really minds. If they did, just take it down. Be careful though, and just understand the shady implications of this. Still pretty neat though.

I think we should put our hands up and admire the work that went into this rather than discuss the legal implications. Adriweb posted this to other sites for awareness not for legal discussions.

I again, Adriweb and co, want to applaud your work in this wrapper. I hope to see developments for as long as you guys are able. If there are legal issues with this I would love to see you guys work through them to the best of your ability.

Indeed, that would be more productive for the community of users at large.
Likewise, working on a full-blown community emulator for the TI-eZ80 series, with e.g. debugging support, would be more productive; double bonus points for such an emulator to be open source software

Write a stub-program with CEF that reads the relevant SmartView files directly into RAM from the official SmartView archive file (probably a JAR?).

Substantial non-infringing use here is definitely making screen-recordings with a legal copy of SmartView.

New major version (v2) !

• You do not have to extract/dig in TI's jar file anymore and move/copy files around, just drag&drop the one .jar file on the wrapper, and that's all!
  
• Minor improvements to the CSS
  
• Bugfixes related to event handling in general
  
• Better compatibility with Firefox and Safari
  
• Some code cleanup

Source code: https://github.com/TI-Planet/ti_jsemu_wrapper
Online demo: http://ti-planet.github.io/ti_jsemu_wrapper/demo/

I think this is a good move, both from a UX perspective, and from a potential copyright issues perspective.